prompt
stringlengths 1.3k
3.64k
| language
stringclasses 16
values | label
int64 -1
5
| text
stringlengths 14
130k
|
|---|---|---|---|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use arrow2::array::*;
#[test]
fn primitive() {
let data = vec![
Some(vec![Some(1i32), Some(2), Some(3)]),
Some(vec![None, None, None]),
Some(vec![Some(4), None, Some(6)]),
];
let mut list = MutableFixedSizeListArray::new(MutablePrimitiveArray::<i32>::new(), 3);
list.try_extend(data).unwrap();
let list: FixedSizeListArray = list.into();
let a = list.value(0);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![Some(1i32), Some(2), Some(3)]);
assert_eq!(a, &expected);
let a = list.value(1);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![None, None, None]);
assert_eq!(a, &expected)
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 3 | use arrow2::array::*;
#[test]
fn primitive() {
let data = vec![
Some(vec![Some(1i32), Some(2), Some(3)]),
Some(vec![None, None, None]),
Some(vec![Some(4), None, Some(6)]),
];
let mut list = MutableFixedSizeListArray::new(MutablePrimitiveArray::<i32>::new(), 3);
list.try_extend(data).unwrap();
let list: FixedSizeListArray = list.into();
let a = list.value(0);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![Some(1i32), Some(2), Some(3)]);
assert_eq!(a, &expected);
let a = list.value(1);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![None, None, None]);
assert_eq!(a, &expected)
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
For pagination:
Have a global page number variable:
var pageNumber = 1;
- This page number variable will be reset every time the user hits search... this means the first line of runQuery can be :
pageNumber = 1;
The below for loop will look like this:
const numberOfResultsPerPage = 5;
for (var i = 0 + numberOfResultsPerPage * (pageNumber - 1); i < numberOfResultsPerPage * (pageNumber); i++) {
console.log(filteredBorrowers.length);
fetchBlob(filteredBorrowers[i]);
}
Next steps:
Create next page button
onclick = function() {
// extra credit: Don't let the pages be too big or small
pageNumber = pageNumber + 1;
renderResults();
// same as pageNumber += 1;
}
*/
// create a borrowers variable to later assign it to borrowers.json database
var borrowers;
$(function () {
//initAutocomplete() to execute Google Map functionalities
$(document).ready(function ($) {
initAutocomplete();
});
// use fetch to retrieve borrowers.json database, and report any errors that occur in the fetch operation
// once the borrowers have been successfully loaded and formatted as a JSON object
// using response.json(), run the initialize() function
fetch('borrowers.json').then(function (response) {
if (response.ok) {
response.json().then(function (json) {
borrowers = json;
initialize();
});
} else {
console.log('Network request for borrowers.json failed with response '
+ response.status + ': ' + response.statusText);
}
});
})
// Reset button that clears all search filters and returns all borrowers info //
// SEARCH FEATURES //
// reads filters and searchbox then filter json
function runQuery() {
var borrowerType = document.querySelector('.borrower-type').value;
let doesBorrowerTypeExist;
if (borrowerType === '') {
doesBorrowerTypeExist = false;
} else {
doesBorrowerTypeExist = true;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | /*
For pagination:
Have a global page number variable:
var pageNumber = 1;
- This page number variable will be reset every time the user hits search... this means the first line of runQuery can be :
pageNumber = 1;
The below for loop will look like this:
const numberOfResultsPerPage = 5;
for (var i = 0 + numberOfResultsPerPage * (pageNumber - 1); i < numberOfResultsPerPage * (pageNumber); i++) {
console.log(filteredBorrowers.length);
fetchBlob(filteredBorrowers[i]);
}
Next steps:
Create next page button
onclick = function() {
// extra credit: Don't let the pages be too big or small
pageNumber = pageNumber + 1;
renderResults();
// same as pageNumber += 1;
}
*/
// create a borrowers variable to later assign it to borrowers.json database
var borrowers;
$(function () {
//initAutocomplete() to execute Google Map functionalities
$(document).ready(function ($) {
initAutocomplete();
});
// use fetch to retrieve borrowers.json database, and report any errors that occur in the fetch operation
// once the borrowers have been successfully loaded and formatted as a JSON object
// using response.json(), run the initialize() function
fetch('borrowers.json').then(function (response) {
if (response.ok) {
response.json().then(function (json) {
borrowers = json;
initialize();
});
} else {
console.log('Network request for borrowers.json failed with response '
+ response.status + ': ' + response.statusText);
}
});
})
// Reset button that clears all search filters and returns all borrowers info //
// SEARCH FEATURES //
// reads filters and searchbox then filter json
function runQuery() {
var borrowerType = document.querySelector('.borrower-type').value;
let doesBorrowerTypeExist;
if (borrowerType === '') {
doesBorrowerTypeExist = false;
} else {
doesBorrowerTypeExist = true;
}
var sector = document.querySelector('.sector').value;
let doesSectorExist;
if (sector === '') {
doesSectorExist = false;
} else {
doesSectorExist = true;
}
var searchTerm = document.querySelector('.search-term').value;
let doesSearchTermsExist;
if (searchTerm === '') {
doesSearchTermsExist = false;
} else {
doesSearchTermsExist = true;
}
let filteredBorrowers
// Filter by type
filteredBorrowers = borrowers.filter(function (borrower) {
// if (doesBorrowerTypeExist) {
// if (borrower.type !== borrowerType) {
// return false;
// }
// }
if (doesBorrowerTypeExist && (borrower.type !== borrowerType)) {
return false;
}
// Then Filter by sector
if (doesSectorExist && (borrower.sector !== sector)) {
return false;
}
// Then Filter by search term
if (doesSearchTermsExist && (!borrower.keywords.includes(searchTerm))) {
return false;
}
return true;
});
finalGroup = filteredBorrowers;
renderResults();
}
// clear and generate new results //
function renderResults() {
// start the process of updating the display with the new set of borrowers
// remove the previous contents of the <main> element
while (main.firstChild) {
main.removeChild(main.firstChild);
}
// if no borrowers match the search term, display a "No results to display" message
if (finalGroup.length === 0) {
var para = document.createElement('p');
para.textContent = 'No results to display!';
main.appendChild(para);
// for each borrower we want to display, pass its borrower object to fetchBlob()
} else {
for (var i = 0; i < finalGroup.length; i++) {
fetchBlob(finalGroup[i]);
}
}
}
function fetchBlob(borrower) {
showResult(borrower);
}
// Display a borrower inside the <main> element
function showResult(borrower) {
// create sub-elements inside <main>
var section = document.createElement('section');
var heading = document.createElement('h1');
var titles = document.createElement('h2');
var description = document.createElement('p2');
var para = document.createElement('p');
var image = document.createElement('img');
var website = document.createElement('a1');
var kiva = document.createElement('a2');
// give the <section> a classname equal to the borrower "type" property so it will display the correct icon
// section.setAttribute('class', borrower.type);
// Give values to newly created elements
heading.textContent = borrower.name;
description.innerText = borrower.sector;
titles.innerText = "Business Name:" + "\n" + "Address:" + "\n" + " " + "\n" + "Phone:" + "\n" + "Email:";
para.innerText = borrower.businessName + "\n" + borrower.address1 + "\n" +
borrower.address2 + "\n" + borrower.phone + "\n" + borrower.email;
image.src = borrower.image;
website.innerHTML = ("Website").link(borrower.website);
kiva.innerHTML = ("<NAME>").link(borrower.kivaLink);
// append the elements to the DOM as appropriate, to add the borrower to the UI
main.appendChild(section);
section.appendChild(heading);
section.appendChild(titles);
section.appendChild(description);
section.appendChild(para);
section.appendChild(image);
section.appendChild(website);
section.appendChild(kiva);
}
// sets up the app logic, declares required variables, contains all the other functions
function initialize() {
var borrowerType = document.querySelector('.borrower-type');
var sector = document.querySelector('.sector');
var searchTerm = document.querySelector('.search-term');
var searchButton = document.querySelector('.search-button');
main = document.querySelector('main');
// keep a record of what the last filters entered were
var lastBorrowerType = borrowerType.value;
var lastSector = sector.value;
var lastSearchTerm = ''; //since no search term had been entered yet
// typeGroup and sectorGroup contain results after filtering by borrower type, sector, and search term
// finalGroup will contain the borrowers that need to be displayed after
// the searching has been done. Each will be an array containing objects.
// Each object will represent a borrower
var typeGroup;
var sectorGroup;
var finalGroup;
// To start with, set finalGroup to equal the entire borrowers.json database
// then run updateDisplay(), so ALL borrowers are displayed initially.
finalGroup = borrowers;
updateDisplay();
// Set both to equal an empty array, in time for searches to be run
typeGroup = [];
sectorGroup = [];
finalGroup = [];
// when the search button is clicked, invoke selectCategory() to start
// a search running to select the category of products we want to display
$(document).on('click', '.search-button', function () {
/* Homework
1. runQuery() here and save the filtered results as a global `filteredResults`
2. Fill out a renderResults() function and have it clear out `.main` and re-generate the results from the global `filteredResults`
*/
selectType();
});
// when the reset button is clicked, set finalGroup equals to database
//then invoke UpdateDisplay() to display all borrowers
$(document).on('click', '.reset-button', function () {
finalGroup = borrowers;
updateDisplay();
// also reset the selected value and entered search term to default
$(".borrower-type").each(function () { this.selectedIndex = 0 });
$(".sector").each(function () { this.selectedIndex = 0 });
$(".search-term").val("");
});
function selectType() {
// Set these back to empty arrays, to clear out the previous search
typeGroup = [];
sectorGroup = [];
finalGroup = [];
// if the category and search term are the same as they were the last time a
// search was run, the results will be the same, so there is no point running
// it again — just return out of the function
if (borrowerType.value === lastBorrowerType && sector.value ===
lastSector && searchTerm.value.trim() === lastSearchTerm) {
return;
} else {
// update the record of last category and search term
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
// In this case we want to select all borrowerss, then filter them by the search
// term, so we just set categoryGroup to the entire JSON object, then run selectSector()
if (borrowerType.value === 'All' || borrowerType.value === 'Borrower Type') {
typeGroup = borrowers;
selectSector();
// If a specific category is chosen, we need to filter out the borrowerss not in that
// category, then put the remaining borrowerss inside categoryGroup, before running
// selectSecotr()
} else {
// the values in the <option> elements are uppercase, whereas the categories
// store in the JSON (under "type") are lowercase. We therefore need to convert
// to lower case before we do a comparison
for (var i = 0; i < borrowers.length; i++) {
// If a borrower's type property is the same as the chosen category, we want to
// dispay it, so we push it onto the categoryGroup array
if (borrowers[i].type === borrowerType.value) {
typeGroup.push(borrowers[i]);
}
}
// Run selectSector() after the filtering has been done
selectSector();
}
}
}
function selectSector() {
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
if (sector.value === 'All' || sector.value === 'Business Sector') {
finalGroup = typeGroup;
updateDisplay();
// If a specific category is chosen, we need to filter out the borrowers not in that
// category, then put the remaining borrowers inside categoryGroup, before running
// selectTerms()
} else {
for (var i = 0; i < borrowers.length; i++) {
// If a borrower's type property is the same as the chosen category, we want to
// dispay it, so we push it onto the categoryGroup array
if (borrowers[i].sector === sector.value) {
sectorGroup.push(typeGroup[i]);
}
// run selectTerms() after this second round of filtering has been done
selectTerms();
}
}
}
// selectTerms() Takes the group of borrowers selected by selectCategory(), and further
// filters them by the tnered search term (if one has bene entered)
function selectTerms() {
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
// If no search term has been entered, just make the finalGroup array equal to the categoryGroup
// array — we don't want to filter the borrowers further — then run updateDisplay().
if (searchTerm.value.trim() === '') {
finalGroup = sectorGroup;
updateDisplay();
} else {
// Make sure the search term is converted to lower case before comparison. We've kept the
// borrower names all lower case to keep things simple
var lowerCaseSearchTerm = searchTerm.value.trim().toLowerCase();
// For each borrower in categoryGroup, see if the search term is contained inside the borrower name
// (if the indexOf() result doesn't return -1, it means it is) — if it is, then push the borrower
// onto the finalGroup array -- sectorGroup[i].keywords.indexOf(lowerCaseSearchTerm) !== -1
for (var i = 0; i < sectorGroup.length; i++) {
if (sectorGroup.includes(sectorGroup[i].keywords)) {
finalGroup.push(sectorGroup[i]);
}
}
// run updateDisplay() after this last round of filtering has been done
updateDisplay();
}
}
// start the process of updating the display with the new set of borrowers
function updateDisplay() {
// remove the previous contents of the <main> element
while (main.firstChild) {
main.removeChild(main.firstChild);
}
// if no borrowers match the search term, display a "No results to display" message
if (finalGroup.length === 0) {
var para = document.createElement('p');
para.textContent = 'No results to display!';
main.appendChild(para);
// for each borrower we want to display, pass its borrower object to fetchBlob()
} else {
for (var i = 0; i < finalGroup.length; i++) {
fetchBlob(finalGroup[i]);
}
}
}
function fetchBlob(borrower) {
showResult(borrower);
}
// Display a borrower inside the <main> element
function showResult(borrower) {
// create sub-elements inside <main>
var section = document.createElement('section');
var heading = document.createElement('h1');
var titles = document.createElement('h2');
var description = document.createElement('p2');
var para = document.createElement('p');
var image = document.createElement('img');
var website = document.createElement('a1');
var kiva = document.createElement('a2');
// give the <section> a classname equal to the borrower "type" property so it will display the correct icon
// section.setAttribute('class', borrower.type);
// Give values to newly created elements
heading.textContent = borrower.name;
description.innerText = borrower.sector;
titles.innerText = "Business Name:" + "\n" + "Address:" + "\n" + " " + "\n" + "Phone:" + "\n" + "Email:";
para.innerText = borrower.businessName + "\n" + borrower.address1 + "\n" +
borrower.address2 + "\n" + borrower.phone + "\n" + borrower.email;
image.src = borrower.image;
website.innerHTML = ("Website").link(borrower.website);
kiva.innerHTML = ("<NAME>").link(borrower.kivaLink);
// append the elements to the DOM as appropriate, to add the borrower to the UI
main.appendChild(section);
section.appendChild(heading);
section.appendChild(titles);
section.appendChild(description);
section.appendChild(para);
section.appendChild(image);
section.appendChild(website);
section.appendChild(kiva);
}
}
// MAP //
function initAutocomplete() {
var map = new google.maps.Map(document.getElementById('map'), {
center: { lat: 37.321488, lng: -121.878506 },
zoom: 13,
mapTypeId: 'roadmap'
});
// Create the search box and link it to the UI element.
var input = document.getElementById('pac-input');
var searchBox = new google.maps.places.SearchBox(input);
map.controls[google.maps.ControlPosition.TOP_LEFT].push(input);
// Bias the SearchBox results towards current map's viewport.
map.addListener('bounds_changed', function () {
searchBox.setBounds(map.getBounds());
});
var markers = [];
// Listen for the event fired when the user selects a prediction and retrieve
// more details for that place.
searchBox.addListener('places_changed', function () {
var places = searchBox.getPlaces();
if (places.length == 0) {
return;
}
// Clear out the old markers.
markers.forEach(function (marker) {
marker.setMap(null);
});
markers = [];
// For each place, get the icon, name and location.
var bounds = new google.maps.LatLngBounds();
places.forEach(function (place) {
if (!place.geometry) {
console.log("Returned place contains no geometry");
return;
}
var icon = {
url: place.icon,
size: new google.maps.Size(71, 71),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(17, 34),
scaledSize: new google.maps.Size(25, 25)
};
// Create a marker for each place.
markers.push(new google.maps.Marker({
map: map,
icon: icon,
title: place.name,
position: place.geometry.location
}));
if (place.geometry.viewport) {
// Only geocodes have viewport.
bounds.union(place.geometry.viewport);
} else {
bounds.extend(place.geometry.location);
}
});
map.fitBounds(bounds);
});
} |
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace SuusApi\Client;
class LineAddress
{
/**
* @var string $lp
*/
protected $lp = null;
/**
* @var string $type
*/
protected $type = null;
/**
* @var string $name
*/
protected $name = null;
/**
* @var string $street
*/
protected $street = null;
/**
* @var string $streetNo
*/
protected $streetNo = null;
/**
* @var string $postCode
*/
protected $postCode = null;
/**
* @var string $city
*/
protected $city = null;
/**
* @var string $country
*/
protected $country = null;
/**
* @var date $dateFrom
*/
protected $dateFrom = null;
/**
* @var string $timeFrom
*/
protected $timeFrom = null;
/**
* @var string $dateTo
*/
protected $dateTo = null;
/**
* @var string $timeTo
*/
protected $timeTo = null;
/**
* @var string $cargo
*/
protected $cargo = null;
/**
* @var boolean $fullTruck
*/
protected $fullTruck = null;
/**
* @var string $symbol
*/
protected $symbol = null;
/**
* @var int $quantity
*/
protected $quantity = null;
/**
* @var float $weightKg
*/
protected $weightKg = null;
/**
* @var float $lenghtM
*/
protected $lenghtM = null;
/**
* @var float $widthM
*/
protected $widthM = null;
/**
* @var float $heightM
*/
protected $heightM = null;
/**
* @var float $loadingMeters
*/
protected $loadingMeters = null;
/**
* @var string $reference
*/
protected $reference = null;
/**
* @param string $lp
* @param string $type
* @param string $name
* @param string $street
* @param string $streetNo
* @param string $postCode
* @param string $city
* @param string $country
* @param boolean $fullTruck
* @param string $sy
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 | <?php
namespace SuusApi\Client;
class LineAddress
{
/**
* @var string $lp
*/
protected $lp = null;
/**
* @var string $type
*/
protected $type = null;
/**
* @var string $name
*/
protected $name = null;
/**
* @var string $street
*/
protected $street = null;
/**
* @var string $streetNo
*/
protected $streetNo = null;
/**
* @var string $postCode
*/
protected $postCode = null;
/**
* @var string $city
*/
protected $city = null;
/**
* @var string $country
*/
protected $country = null;
/**
* @var date $dateFrom
*/
protected $dateFrom = null;
/**
* @var string $timeFrom
*/
protected $timeFrom = null;
/**
* @var string $dateTo
*/
protected $dateTo = null;
/**
* @var string $timeTo
*/
protected $timeTo = null;
/**
* @var string $cargo
*/
protected $cargo = null;
/**
* @var boolean $fullTruck
*/
protected $fullTruck = null;
/**
* @var string $symbol
*/
protected $symbol = null;
/**
* @var int $quantity
*/
protected $quantity = null;
/**
* @var float $weightKg
*/
protected $weightKg = null;
/**
* @var float $lenghtM
*/
protected $lenghtM = null;
/**
* @var float $widthM
*/
protected $widthM = null;
/**
* @var float $heightM
*/
protected $heightM = null;
/**
* @var float $loadingMeters
*/
protected $loadingMeters = null;
/**
* @var string $reference
*/
protected $reference = null;
/**
* @param string $lp
* @param string $type
* @param string $name
* @param string $street
* @param string $streetNo
* @param string $postCode
* @param string $city
* @param string $country
* @param boolean $fullTruck
* @param string $symbol
* @param int $quantity
* @param float $weightKg
* @param float $lenghtM
* @param float $widthM
* @param float $heightM
* @param float $loadingMeters
* @param string $reference
*/
public function __construct($lp, $type, $name, $street, $streetNo, $postCode, $city, $country, $fullTruck, $symbol, $quantity, $weightKg, $lenghtM, $widthM, $heightM, $loadingMeters, $reference)
{
$this->lp = $lp;
$this->type = $type;
$this->name = $name;
$this->street = $street;
$this->streetNo = $streetNo;
$this->postCode = $postCode;
$this->city = $city;
$this->country = $country;
$this->fullTruck = $fullTruck;
$this->symbol = $symbol;
$this->quantity = $quantity;
$this->weightKg = $weightKg;
$this->lenghtM = $lenghtM;
$this->widthM = $widthM;
$this->heightM = $heightM;
$this->loadingMeters = $loadingMeters;
$this->reference = $reference;
}
/**
* @return string
*/
public function getLp()
{
return $this->lp;
}
/**
* @param string $lp
* @return \SuusApi\Client\LineAddress
*/
public function setLp($lp)
{
$this->lp = $lp;
return $this;
}
/**
* @return string
*/
public function getType()
{
return $this->type;
}
/**
* @param string $type
* @return \SuusApi\Client\LineAddress
*/
public function setType($type)
{
$this->type = $type;
return $this;
}
/**
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* @param string $name
* @return \SuusApi\Client\LineAddress
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* @return string
*/
public function getStreet()
{
return $this->street;
}
/**
* @param string $street
* @return \SuusApi\Client\LineAddress
*/
public function setStreet($street)
{
$this->street = $street;
return $this;
}
/**
* @return string
*/
public function getStreetNo()
{
return $this->streetNo;
}
/**
* @param string $streetNo
* @return \SuusApi\Client\LineAddress
*/
public function setStreetNo($streetNo)
{
$this->streetNo = $streetNo;
return $this;
}
/**
* @return string
*/
public function getPostCode()
{
return $this->postCode;
}
/**
* @param string $postCode
* @return \SuusApi\Client\LineAddress
*/
public function setPostCode($postCode)
{
$this->postCode = $postCode;
return $this;
}
/**
* @return string
*/
public function getCity()
{
return $this->city;
}
/**
* @param string $city
* @return \SuusApi\Client\LineAddress
*/
public function setCity($city)
{
$this->city = $city;
return $this;
}
/**
* @return string
*/
public function getCountry()
{
return $this->country;
}
/**
* @param string $country
* @return \SuusApi\Client\LineAddress
*/
public function setCountry($country)
{
$this->country = $country;
return $this;
}
/**
* @return date
*/
public function getDateFrom()
{
return $this->dateFrom;
}
/**
* @param date $dateFrom
* @return \SuusApi\Client\LineAddress
*/
public function setDateFrom($dateFrom)
{
$this->dateFrom = $dateFrom;
return $this;
}
/**
* @return string
*/
public function getTimeFrom()
{
return $this->timeFrom;
}
/**
* @param string $timeFrom
* @return \SuusApi\Client\LineAddress
*/
public function setTimeFrom($timeFrom)
{
$this->timeFrom = $timeFrom;
return $this;
}
/**
* @return string
*/
public function getDateTo()
{
return $this->dateTo;
}
/**
* @param string $dateTo
* @return \SuusApi\Client\LineAddress
*/
public function setDateTo($dateTo)
{
$this->dateTo = $dateTo;
return $this;
}
/**
* @return string
*/
public function getTimeTo()
{
return $this->timeTo;
}
/**
* @param string $timeTo
* @return \SuusApi\Client\LineAddress
*/
public function setTimeTo($timeTo)
{
$this->timeTo = $timeTo;
return $this;
}
/**
* @return string
*/
public function getCargo()
{
return $this->cargo;
}
/**
* @param string $cargo
* @return \SuusApi\Client\LineAddress
*/
public function setCargo($cargo)
{
$this->cargo = $cargo;
return $this;
}
/**
* @return boolean
*/
public function getFullTruck()
{
return $this->fullTruck;
}
/**
* @param boolean $fullTruck
* @return \SuusApi\Client\LineAddress
*/
public function setFullTruck($fullTruck)
{
$this->fullTruck = $fullTruck;
return $this;
}
/**
* @return string
*/
public function getSymbol()
{
return $this->symbol;
}
/**
* @param string $symbol
* @return \SuusApi\Client\LineAddress
*/
public function setSymbol($symbol)
{
$this->symbol = $symbol;
return $this;
}
/**
* @return int
*/
public function getQuantity()
{
return $this->quantity;
}
/**
* @param int $quantity
* @return \SuusApi\Client\LineAddress
*/
public function setQuantity($quantity)
{
$this->quantity = $quantity;
return $this;
}
/**
* @return float
*/
public function getWeightKg()
{
return $this->weightKg;
}
/**
* @param float $weightKg
* @return \SuusApi\Client\LineAddress
*/
public function setWeightKg($weightKg)
{
$this->weightKg = $weightKg;
return $this;
}
/**
* @return float
*/
public function getLenghtM()
{
return $this->lenghtM;
}
/**
* @param float $lenghtM
* @return \SuusApi\Client\LineAddress
*/
public function setLenghtM($lenghtM)
{
$this->lenghtM = $lenghtM;
return $this;
}
/**
* @return float
*/
public function getWidthM()
{
return $this->widthM;
}
/**
* @param float $widthM
* @return \SuusApi\Client\LineAddress
*/
public function setWidthM($widthM)
{
$this->widthM = $widthM;
return $this;
}
/**
* @return float
*/
public function getHeightM()
{
return $this->heightM;
}
/**
* @param float $heightM
* @return \SuusApi\Client\LineAddress
*/
public function setHeightM($heightM)
{
$this->heightM = $heightM;
return $this;
}
/**
* @return float
*/
public function getLoadingMeters()
{
return $this->loadingMeters;
}
/**
* @param float $loadingMeters
* @return \SuusApi\Client\LineAddress
*/
public function setLoadingMeters($loadingMeters)
{
$this->loadingMeters = $loadingMeters;
return $this;
}
/**
* @return string
*/
public function getReference()
{
return $this->reference;
}
/**
* @param string $reference
* @return \SuusApi\Client\LineAddress
*/
public function setReference($reference)
{
$this->reference = $reference;
return $this;
}
}
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import java.util.Scanner;
public class Family
{
private static String sur_name;
private String first_name, last_name;
private int year_of_birth;
public static void getSurName()
{
Scanner inputTaker = new Scanner(System.in);
System.out.println("Enter the family name : ");
sur_name = inputTaker.nextLine();
}
public void input()
{
Scanner myScanner = new Scanner(System.in);
System.out.println("\nFirstName : ");
first_name = myScanner.nextLine();
System.out.println("\nLastName : ");
last_name = myScanner.nextLine();
System.out.println("\nYear of birth : ");
year_of_birth =myScanner.nextInt();
}
public void output()
{
System.out.println("\nLastName : "+last_name);
System.out.println("\nFirstName : "+first_name);
System.out.println("\nSurName : "+sur_name);
System.out.println("\nYear of Birth : "+year_of_birth);
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 2 | import java.util.Scanner;
public class Family
{
private static String sur_name;
private String first_name, last_name;
private int year_of_birth;
public static void getSurName()
{
Scanner inputTaker = new Scanner(System.in);
System.out.println("Enter the family name : ");
sur_name = inputTaker.nextLine();
}
public void input()
{
Scanner myScanner = new Scanner(System.in);
System.out.println("\nFirstName : ");
first_name = myScanner.nextLine();
System.out.println("\nLastName : ");
last_name = myScanner.nextLine();
System.out.println("\nYear of birth : ");
year_of_birth =myScanner.nextInt();
}
public void output()
{
System.out.println("\nLastName : "+last_name);
System.out.println("\nFirstName : "+first_name);
System.out.println("\nSurName : "+sur_name);
System.out.println("\nYear of Birth : "+year_of_birth);
}
}
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use crate::{
components::{GridLocation, Thing, ThingTape},
resources::RewindableClock,
utils::{move_tape_backwards, move_tape_forwards},
};
use amethyst::{
derive::SystemDesc,
ecs::prelude::{Join, Read, System, SystemData, WriteStorage},
};
#[derive(SystemDesc)]
pub struct ThingTapeSystem;
impl<'s> System<'s> for ThingTapeSystem {
type SystemData = (
Read<'s, RewindableClock>,
WriteStorage<'s, Thing>,
WriteStorage<'s, GridLocation>,
WriteStorage<'s, ThingTape>,
);
fn run(&mut self, (clock, mut things, mut grid_locations, mut thing_tapes): Self::SystemData) {
if clock.velocity == 0 {
return;
}
for (thing, thing_grid_location, thing_tape) in
(&mut things, &mut grid_locations, &mut thing_tapes).join()
{
let snapshots = &mut thing_tape.snapshots;
if clock.going_forwards() {
debug!("Going forwards");
move_tape_forwards(snapshots, thing_grid_location, thing);
} else {
debug!("Going backward");
move_tape_backwards(snapshots, thing_grid_location, thing);
}
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | use crate::{
components::{GridLocation, Thing, ThingTape},
resources::RewindableClock,
utils::{move_tape_backwards, move_tape_forwards},
};
use amethyst::{
derive::SystemDesc,
ecs::prelude::{Join, Read, System, SystemData, WriteStorage},
};
#[derive(SystemDesc)]
pub struct ThingTapeSystem;
impl<'s> System<'s> for ThingTapeSystem {
type SystemData = (
Read<'s, RewindableClock>,
WriteStorage<'s, Thing>,
WriteStorage<'s, GridLocation>,
WriteStorage<'s, ThingTape>,
);
fn run(&mut self, (clock, mut things, mut grid_locations, mut thing_tapes): Self::SystemData) {
if clock.velocity == 0 {
return;
}
for (thing, thing_grid_location, thing_tape) in
(&mut things, &mut grid_locations, &mut thing_tapes).join()
{
let snapshots = &mut thing_tape.snapshots;
if clock.going_forwards() {
debug!("Going forwards");
move_tape_forwards(snapshots, thing_grid_location, thing);
} else {
debug!("Going backward");
move_tape_backwards(snapshots, thing_grid_location, thing);
}
}
}
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import React, { Component } from 'react';
import styled from 'styled-components';
import { BrowserRouter, Route, Switch } from 'react-router-dom';
import ScrollToTop from './ScrollToTop';
import PokemonList from './PokemonList';
import PokemonDetails from './PokemonDetails';
import Header from './Header';
const StyledApp = styled.div`
text-align: center;
margin: 0 auto;
.page {
margin-top: 80px;
margin-left: 5%;
margin-right: 5%;
z-index: 0;
}
`;
class App extends Component {
render() {
return (
<BrowserRouter>
<ScrollToTop>
<StyledApp>
<Header />
<div className="page">
<Switch>
<Route path="/" exact component={PokemonList} />
<Route path="/pokemon/:name" component={PokemonDetails} />
</Switch>
</div>
</StyledApp>
</ScrollToTop>
</BrowserRouter>
);
}
}
export default App;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import React, { Component } from 'react';
import styled from 'styled-components';
import { BrowserRouter, Route, Switch } from 'react-router-dom';
import ScrollToTop from './ScrollToTop';
import PokemonList from './PokemonList';
import PokemonDetails from './PokemonDetails';
import Header from './Header';
const StyledApp = styled.div`
text-align: center;
margin: 0 auto;
.page {
margin-top: 80px;
margin-left: 5%;
margin-right: 5%;
z-index: 0;
}
`;
class App extends Component {
render() {
return (
<BrowserRouter>
<ScrollToTop>
<StyledApp>
<Header />
<div className="page">
<Switch>
<Route path="/" exact component={PokemonList} />
<Route path="/pokemon/:name" component={PokemonDetails} />
</Switch>
</div>
</StyledApp>
</ScrollToTop>
</BrowserRouter>
);
}
}
export default App;
|
Below is an extract from an HTML document. Evaluate whether it has a high educational value and could help teach web development. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document contains valid HTML markup, even if it's not educational, like boilerplate code or standard tags.
- Add another point if the document addresses practical HTML concepts and uses semantic elements appropriately.
- Award a third point if the document is suitable for educational use and introduces key web concepts, even if the topic is somewhat advanced (e.g., forms, metadata). The code should be well-structured and use clear, descriptive naming.
- Give a fourth point if the document is self-contained and highly relevant to teaching HTML. It should be similar to a school exercise, a tutorial, or an HTML course section for early learners.
- Grant a fifth point if the document is outstanding in its educational value and is perfectly suited for teaching HTML to beginners. It should be well-organized, easy to understand, and ideally include some explanatory comments or demonstrate best practices in HTML structure.
The extract:
---
layout: post
title: 登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）
date: '2012-07-01T06:55:00.001+09:00'
author: <NAME>
tags:
- Postgres
modified_time: '2012-07-01T06:55:30.409+09:00'
blogger_id: tag:blogger.com,1999:blog-2052559951721308867.post-380298435368333858
blogger_orig_url: http://uedatakeshi.blogspot.com/2012/07/casemax.html
---
<h1>登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）</h1><p>登録日が created で、更新日が modified で、データを新規登録した時にね、<br />
created には insert するけど、modified にはしない。<br />
本当に編集した時だけ modified に入れるようなプログラムになってたとするじゃないですか。<br />
</p><p>そうするとデータはこんな感じになる訳で。<br />
<br />
<pre class="brush: shell"> created | modified
----------------------------+----------------------------
2009-03-17 10:18:24.792449 | 2009-03-17 10:32:55.900294
2009-03-25 19:32:18.205694 |
2009-03-26 14:44:18.787866 |
2009-03-30 16:56:56.128813 |
2012-06-22 18:26:11.540513 |
2012-06-23 12:18:09.649044 |
2012-06-22 18:26:37.815316 | 2012-06-26 15:07:45.34223
2012-06-21 12:46:03.151537 | 2012-06-26 16:44:05.811683
2012-06-26 19:05:44.473284 | 2012-06-26 20:15:18.196717
</pre> <br />
modified は NULL になってるデータがある訳です。</p><p>こういう状態で、更新があった一番新しい日付をセレクトせよ、ってことなんですが。。。</p> <br />
<pre class="brush: sql"> SELECT MAX(CASE WHEN modified IS NULL THEN created ELSE modified END) AS dates FROM items;
</pre> <br />
<p>これでこうなる。 <br />
<pre class="brush: shell"> dates
----------------------------
2012-06-26 20:15:18.196717
(1 row)
</pre>まあ、最初っから両方入れとけよって話ですね。</p><br />
<br />
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| html | 1 | ---
layout: post
title: 登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）
date: '2012-07-01T06:55:00.001+09:00'
author: <NAME>
tags:
- Postgres
modified_time: '2012-07-01T06:55:30.409+09:00'
blogger_id: tag:blogger.com,1999:blog-2052559951721308867.post-380298435368333858
blogger_orig_url: http://uedatakeshi.blogspot.com/2012/07/casemax.html
---
<h1>登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）</h1><p>登録日が created で、更新日が modified で、データを新規登録した時にね、<br />
created には insert するけど、modified にはしない。<br />
本当に編集した時だけ modified に入れるようなプログラムになってたとするじゃないですか。<br />
</p><p>そうするとデータはこんな感じになる訳で。<br />
<br />
<pre class="brush: shell"> created | modified
----------------------------+----------------------------
2009-03-17 10:18:24.792449 | 2009-03-17 10:32:55.900294
2009-03-25 19:32:18.205694 |
2009-03-26 14:44:18.787866 |
2009-03-30 16:56:56.128813 |
2012-06-22 18:26:11.540513 |
2012-06-23 12:18:09.649044 |
2012-06-22 18:26:37.815316 | 2012-06-26 15:07:45.34223
2012-06-21 12:46:03.151537 | 2012-06-26 16:44:05.811683
2012-06-26 19:05:44.473284 | 2012-06-26 20:15:18.196717
</pre> <br />
modified は NULL になってるデータがある訳です。</p><p>こういう状態で、更新があった一番新しい日付をセレクトせよ、ってことなんですが。。。</p> <br />
<pre class="brush: sql"> SELECT MAX(CASE WHEN modified IS NULL THEN created ELSE modified END) AS dates FROM items;
</pre> <br />
<p>これでこうなる。 <br />
<pre class="brush: shell"> dates
----------------------------
2012-06-26 20:15:18.196717
(1 row)
</pre>まあ、最初っから両方入れとけよって話ですね。</p><br />
<br /> |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import CustomerDataShareApi from '../customerDataShareApi';
describe("customerDataShareApi", () => {
it('renders Default Page correctly', () => {
expect(true).toBe(true);
});
});
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 1 |
import CustomerDataShareApi from '../customerDataShareApi';
describe("customerDataShareApi", () => {
it('renders Default Page correctly', () => {
expect(true).toBe(true);
});
});
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
INPUT : FAKE_FLAG_HACK_THE_BOX_01234567
111111111111111111111111111111
COMMAND : gdb -q --args ./coffee_invocation $INPUT
b *0x0000555555554000+0x00001ead
b *0x0000555555554000+0x00001f0a
b *0x0000555555554000+0x00001f2a
b *0x0000555555554000+0x00001b52
b *0x0000555555554000+0x00001b6f
b *0x0000555555554000+0x00001b24
b *0x0000555555554000+0x00001b3b
b *0x5555555556ae
b *0x55555555574e
b *0x555555555793
*/
char peer1_0[] = { /* Packet 1135 */
0x91, 0x03, 0x34, 0xf1, 0x1d, 0x76, 0x44, 0xe3 };
char peer1_1[] = { /* Packet 1142 */
0x01, 0xc1, 0xcc, 0x4b, 0xc0, 0x79, 0xbf, 0x77,
0x70, 0x67, 0x72, 0x3f, 0x82, 0x92, 0x52, 0x13,
0xcb, 0x16, 0x77, 0x2d, 0xd6, 0xdd, 0x4a, 0xca,
0xee, 0xe7, 0xa6, 0x69, 0x3f, 0xef, 0x4e, 0x4c,
0x8d, 0x75, 0xce, 0x31, 0xec, 0xf4, 0xf5, 0x0e,
0xce, 0x7f, 0xd9, 0x9f, 0x84, 0xad, 0xd5, 0xfa,
0xef, 0xee, 0x39, 0x8a, 0x1e, 0x6a, 0xe8, 0x82,
0xf1, 0x00, 0x48, 0x15, 0x95, 0x62, 0x13, 0xa8,
0x06, 0xb9, 0x3b, 0x39, 0xa2, 0xec, 0xf1, 0x0f,
0x1b, 0x1a, 0x0a, 0xf0, 0x7f, 0x84, 0x08, 0xf5,
0x30, 0xa3, 0xdd, 0x53, 0x2c, 0x6e, 0x90, 0x15,
0x18, 0x6e, 0x78, 0x3a, 0x44, 0x32, 0x2e, 0xcd,
0x76, 0x10, 0x37, 0x20, 0x70, 0xf3, 0x95, 0x43,
0x9d, 0xb5, 0xd5, 0x83, 0x14, 0xc2, 0xa4, 0xa9,
0x76, 0x08, 0xb3, 0x0d, 0x08, 0xeb, 0xe3, 0x2c,
0x6d, 0x0c, 0x68, 0xde, 0x12, 0x85, 0x0b, 0x34,
0x93, 0xf9, 0xb2, 0x93, 0xdc, 0xb8, 0x08, 0xd6,
0xd2, 0x6e, 0x74, 0xab, 0x28, 0xc2, 0xd4, 0x3b,
0x8f, 0xc6, 0x04, 0x7a, 0x71, 0x4d, 0x1c, 0x6e,
0x2d, 0xfd, 0xe7, 0x9b, 0xf2, 0x5f, 0xc6, 0x05,
0x1a, 0x98, 0x87, 0x37, 0x15, 0x57, 0xa6, 0x0d,
0x65, 0x37, 0x94, 0x97, 0x84, 0xb1, 0x90, 0x89,
0x27, 0x88, 0x1e, 0xd6, 0x66, 0xbe, 0xfe, 0x9a,
0x9f, 0x89, 0x29, 0x5f, 0x5d, 0x43, 0xd4, 0x80,
0x24, 0xf7, 0x62, 0x68, 0x60, 0xdd, 0x79, 0x4d,
0x69, 0x3f, 0xaf, 0xa8, 0x9f, 0x58, 0xa8, 0xcf,
0xc3, 0xde, 0x03, 0x67, 0xc5, 0x51, 0x1f, 0x6f,
0x36, 0x83, 0x0a, 0xf5, 0xa5, 0xa1, 0xb4, 0x6f,
0x61, 0x19, 0x6d, 0xd2, 0xdf, 0xdc, 0xf4, 0x8e,
0x7d, 0x5d, 0x8f, 0xc3, 0xcd, 0x92, 0
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 1 | /*
INPUT : FAKE_FLAG_HACK_THE_BOX_01234567
111111111111111111111111111111
COMMAND : gdb -q --args ./coffee_invocation $INPUT
b *0x0000555555554000+0x00001ead
b *0x0000555555554000+0x00001f0a
b *0x0000555555554000+0x00001f2a
b *0x0000555555554000+0x00001b52
b *0x0000555555554000+0x00001b6f
b *0x0000555555554000+0x00001b24
b *0x0000555555554000+0x00001b3b
b *0x5555555556ae
b *0x55555555574e
b *0x555555555793
*/
char peer1_0[] = { /* Packet 1135 */
0x91, 0x03, 0x34, 0xf1, 0x1d, 0x76, 0x44, 0xe3 };
char peer1_1[] = { /* Packet 1142 */
0x01, 0xc1, 0xcc, 0x4b, 0xc0, 0x79, 0xbf, 0x77,
0x70, 0x67, 0x72, 0x3f, 0x82, 0x92, 0x52, 0x13,
0xcb, 0x16, 0x77, 0x2d, 0xd6, 0xdd, 0x4a, 0xca,
0xee, 0xe7, 0xa6, 0x69, 0x3f, 0xef, 0x4e, 0x4c,
0x8d, 0x75, 0xce, 0x31, 0xec, 0xf4, 0xf5, 0x0e,
0xce, 0x7f, 0xd9, 0x9f, 0x84, 0xad, 0xd5, 0xfa,
0xef, 0xee, 0x39, 0x8a, 0x1e, 0x6a, 0xe8, 0x82,
0xf1, 0x00, 0x48, 0x15, 0x95, 0x62, 0x13, 0xa8,
0x06, 0xb9, 0x3b, 0x39, 0xa2, 0xec, 0xf1, 0x0f,
0x1b, 0x1a, 0x0a, 0xf0, 0x7f, 0x84, 0x08, 0xf5,
0x30, 0xa3, 0xdd, 0x53, 0x2c, 0x6e, 0x90, 0x15,
0x18, 0x6e, 0x78, 0x3a, 0x44, 0x32, 0x2e, 0xcd,
0x76, 0x10, 0x37, 0x20, 0x70, 0xf3, 0x95, 0x43,
0x9d, 0xb5, 0xd5, 0x83, 0x14, 0xc2, 0xa4, 0xa9,
0x76, 0x08, 0xb3, 0x0d, 0x08, 0xeb, 0xe3, 0x2c,
0x6d, 0x0c, 0x68, 0xde, 0x12, 0x85, 0x0b, 0x34,
0x93, 0xf9, 0xb2, 0x93, 0xdc, 0xb8, 0x08, 0xd6,
0xd2, 0x6e, 0x74, 0xab, 0x28, 0xc2, 0xd4, 0x3b,
0x8f, 0xc6, 0x04, 0x7a, 0x71, 0x4d, 0x1c, 0x6e,
0x2d, 0xfd, 0xe7, 0x9b, 0xf2, 0x5f, 0xc6, 0x05,
0x1a, 0x98, 0x87, 0x37, 0x15, 0x57, 0xa6, 0x0d,
0x65, 0x37, 0x94, 0x97, 0x84, 0xb1, 0x90, 0x89,
0x27, 0x88, 0x1e, 0xd6, 0x66, 0xbe, 0xfe, 0x9a,
0x9f, 0x89, 0x29, 0x5f, 0x5d, 0x43, 0xd4, 0x80,
0x24, 0xf7, 0x62, 0x68, 0x60, 0xdd, 0x79, 0x4d,
0x69, 0x3f, 0xaf, 0xa8, 0x9f, 0x58, 0xa8, 0xcf,
0xc3, 0xde, 0x03, 0x67, 0xc5, 0x51, 0x1f, 0x6f,
0x36, 0x83, 0x0a, 0xf5, 0xa5, 0xa1, 0xb4, 0x6f,
0x61, 0x19, 0x6d, 0xd2, 0xdf, 0xdc, 0xf4, 0x8e,
0x7d, 0x5d, 0x8f, 0xc3, 0xcd, 0x92, 0xa8, 0xf9,
0xcb, 0x7e, 0x3d, 0xa1, 0xb9, 0xf0, 0x41, 0x71,
0x90, 0xc8, 0x3a, 0x9d, 0x1d, 0xec, 0x1e, 0x9c,
0x8d, 0x7e, 0x37, 0xd0, 0x6b, 0x5a, 0xc8, 0x22,
0x75, 0x6b, 0x61, 0xcc, 0xa8, 0x89, 0x43, 0x0a,
0x2a, 0x7a, 0x21, 0xbb, 0x07, 0x21, 0x39, 0x1a,
0x36, 0x53, 0x76, 0x39, 0xa4, 0x4a, 0x22, 0xd2,
0x7e, 0x4b, 0x71, 0xfe, 0x48, 0x21, 0x2e, 0x82,
0xf4, 0x4d, 0x74, 0xe4, 0xcf, 0xff, 0xd5, 0x62,
0x1c, 0xab, 0x88, 0xc0, 0xcd, 0xac, 0x3c, 0x22,
0x49, 0xe2, 0x95, 0xac, 0x50, 0xf8, 0x9f, 0x08,
0xe7, 0x03, 0x9e, 0x7f, 0xd0, 0x0b, 0x98, 0x7a,
0x18, 0x2d, 0x21, 0x00, 0x83, 0x51, 0x42, 0xf6,
0xda, 0x25, 0x9d, 0x07, 0x98, 0xac, 0xfb, 0x6f,
0x9e, 0xf3, 0x79, 0xb8, 0x56, 0xb8, 0x85, 0x55,
0x00, 0x19, 0x77, 0x6e, 0xec, 0x75, 0x00, 0x6a,
0x84, 0x7c, 0x3c, 0x5c, 0x78, 0x15, 0x0e, 0x8a,
0x51, 0x78, 0xb8, 0x0d, 0x0b, 0xc8, 0xc5, 0x82,
0xd8, 0xbf, 0xca, 0x47, 0xec, 0x2d, 0x0a, 0xca,
0x95, 0xdb, 0x8d, 0x51, 0x43, 0x4e, 0x14, 0x90,
0xf3, 0xfb, 0x68, 0xb6, 0xa1, 0xa2, 0x52, 0xcd,
0xc1, 0x8a, 0x7e, 0xbb, 0xb8, 0xb8, 0xa4, 0x3c,
0x79, 0xaa, 0xf0, 0xbc, 0x4f, 0xd3, 0x86, 0x1c,
0xb8, 0x3d, 0x5e, 0x19, 0xeb, 0x45, 0xaa, 0xf3,
0x6d, 0x1c, 0xfa, 0x62, 0xa4, 0x28, 0x9a, 0xfd,
0x32, 0x80, 0x6f, 0x1f, 0x9e, 0x5d, 0xaa, 0xc2,
0xcc, 0x53, 0x2d, 0x71, 0xd5, 0xea, 0x66, 0x0e,
0x6f, 0x3f, 0xce, 0x00, 0xc9, 0x25, 0x09, 0x18,
0x7c, 0x1f, 0xc8, 0x4d, 0x36, 0x6e, 0x27, 0xe4,
0x68, 0xd6, 0xb8, 0x19, 0x09, 0x76, 0x93, 0xbf,
0x1e, 0x99, 0x35, 0x95, 0x02, 0xd8, 0x9a, 0x42,
0xf0, 0x1e, 0xd5, 0x2b, 0x19, 0x46, 0x9c, 0x35,
0x91, 0x32, 0x0f, 0xe9, 0xc4, 0xa7, 0x7d, 0x16,
0xdf, 0xfe, 0x86, 0x1f, 0xd6, 0xb3, 0x93, 0xaa,
0x67, 0x89, 0x4e, 0x0e, 0xbe, 0x38, 0xb5, 0xa2,
0xce, 0x00, 0xb2, 0x22, 0x0b, 0xa4, 0x24, 0xe8,
0xcc, 0x1a, 0x57, 0x0d, 0x11, 0xa5, 0x24, 0x78,
0x89, 0x20, 0x86, 0x69, 0xb0, 0x1f, 0xb1, 0xa1,
0xeb, 0xfe, 0x2f, 0xe9, 0x8f, 0xef, 0x29, 0x89,
0xeb, 0xcb, 0x72, 0x35, 0xfa, 0xb2, 0x27, 0xf5,
0x3b, 0x35, 0xb0, 0x12, 0x0f, 0xa6, 0x50, 0x2a,
0x0e, 0x67, 0xda, 0xac, 0xde, 0x00, 0x8b, 0x2b,
0x2c, 0xc8, 0x25, 0xa7, 0xb3, 0xb6, 0xea, 0x7d,
0xd0, 0x0a, 0x14, 0x26, 0x31, 0xd3, 0xab, 0x45,
0xff, 0x66, 0xca, 0x97, 0x47, 0xab, 0xa6, 0x4a,
0x48, 0xd3, 0x95, 0x64, 0x3c, 0xe2, 0xd6, 0xab,
0x7b, 0x5e, 0xc8, 0x1b, 0x37, 0x49, 0x5e, 0x87,
0xfb, 0x0b, 0x76, 0x50, 0xda, 0xfc, 0x1c, 0x03,
0x17, 0x9d, 0x63, 0x05, 0xfe, 0x99, 0xfe, 0xba,
0x0c, 0x64, 0xab, 0x91, 0xb8, 0x6e, 0x9f, 0x73,
0x0f, 0x46, 0x08, 0x20, 0x7e, 0x2d, 0x7b, 0x07,
0x16, 0x88, 0x78, 0x86, 0x62, 0x8d, 0x94, 0x14,
0x73, 0x4e, 0x7b, 0xdb, 0xe2, 0x6a, 0xfe, 0x20,
0x60, 0x56, 0x57, 0x0d, 0x66, 0xd6, 0x86, 0xa2,
0x99, 0xca, 0xea, 0x08, 0x22, 0x9f, 0x8e, 0x62,
0xe6, 0x1c, 0xe8, 0x5e, 0x0b, 0x83, 0x25, 0xb6,
0xba, 0x2d, 0xf2, 0x95, 0x24, 0x90, 0xe2, 0x55,
0xb7, 0x54, 0x99, 0xd2, 0x6e, 0xbf, 0xc7, 0x8c,
0x54, 0x56, 0xf9, 0x5b, 0x60, 0xea, 0x43, 0xd6,
0xe7, 0xf5, 0x77, 0x86, 0x0b, 0x03, 0x26, 0xe3,
0xec, 0x81, 0xe6, 0xef, 0x2d, 0xee, 0x15, 0x62,
0x05, 0x02, 0xa6, 0xa2, 0xdc, 0x75, 0x9e, 0x72,
0x51, 0x8c, 0x4a, 0x74, 0xa7, 0xf9, 0x2a, 0x05,
0x1e, 0xcf, 0x7c, 0xde, 0xf3, 0xd0, 0x55, 0x8c,
0xe8, 0x5c, 0x35, 0xec, 0xd4, 0x4e, 0x0a, 0xd5,
0x5c, 0x54, 0x81, 0x1c, 0x6e, 0x4e, 0x1d, 0x03,
0x3d, 0xb4, 0x17, 0x7b, 0xd5, 0x75, 0xa1, 0xfa,
0xab, 0xb9, 0x6c, 0x67, 0x7f, 0x8a, 0x0c, 0xf5,
0xa5, 0xde, 0x9b, 0xbb, 0x99, 0xe2, 0x63, 0x65,
0x19, 0xca, 0x0b, 0x7e, 0x62, 0x26, 0x55, 0x78,
0xf2, 0x0b, 0x64, 0x9e, 0xa5, 0x3b, 0x6a, 0x4e,
0xe5, 0x2c, 0x64, 0x90, 0x80, 0xc6, 0x55, 0x15,
0x42, 0x42, 0x69, 0x42, 0xb7, 0xa9, 0x3a, 0x54,
0xf5, 0x0c, 0x42, 0xf7, 0xe8, 0x11, 0xd1, 0x82,
0x41, 0xd9, 0x3e, 0x7a, 0xf5, 0xec, 0xb1, 0x92,
0x17, 0xac, 0xea, 0x3d, 0x8f, 0xa3, 0x22, 0x09,
0x96, 0x0e, 0xae, 0xd1, 0x3b, 0x18, 0xd3, 0x73,
0x7b, 0x5b, 0x28, 0x76, 0x11, 0xa8, 0x3d, 0x79,
0xe5, 0x1d, 0x6a, 0x41, 0x41, 0xec, 0x9a, 0xc3,
0xdc, 0x11, 0x9d, 0x94, 0x7a, 0x93, 0x35, 0x81,
0x85, 0xd8, 0xc1, 0xf8, 0xaa, 0x9e, 0xc1, 0x6b,
0xd4, 0xc6, 0x9c, 0xfa, 0xef, 0x35, 0x65, 0x80,
0x1d, 0xea, 0xcd, 0x01, 0xdb, 0x42, 0xd0, 0x22,
0x6d, 0x62, 0xc5, 0xb6, 0x5d, 0xbf, 0x6b, 0x72,
0xbd, 0x4f, 0x0f, 0x39, 0x93, 0xe5, 0xb9, 0xa2,
0x23, 0xc6, 0x39, 0x5d, 0x2e, 0x3c, 0x42, 0x35,
0x17, 0x80, 0xef, 0x7f, 0x63, 0x00, 0x7f, 0x88,
0x4b, 0x95, 0x6e, 0x3e, 0xf2, 0xba, 0x37, 0xa2,
0x89, 0x49, 0xa2, 0x81, 0x35, 0x59, 0x53, 0xed,
0x07, 0x50, 0x03, 0xf9, 0x9e, 0x6a, 0x80, 0xb3,
0x68, 0x2d, 0xe2, 0xfe, 0xbe, 0x3f, 0x74, 0xc6,
0xc1, 0x19, 0xcb, 0xc7, 0x0d, 0x94, 0x88, 0x66,
0x88, 0xc8, 0x18, 0xc8, 0x08, 0x0f, 0x84, 0x15,
0x55, 0xb9, 0xa0, 0x23, 0xce, 0xaf, 0x5e, 0x6c,
0x41, 0x0e, 0x7f, 0x06, 0x2c, 0x75, 0xed, 0xd8,
0xd2, 0xa8, 0xcf, 0x03, 0x32, 0x43, 0x9b, 0x9d,
0x1a, 0x92, 0x9e, 0xd5, 0x88, 0x19, 0x59, 0x1f,
0x7f, 0x5b, 0x17, 0x8b, 0x6e, 0x0a, 0x33, 0x4b,
0x4e, 0x2f, 0xf0, 0xfd, 0x60, 0x08, 0x0d, 0xda,
0xe3, 0x93, 0x27, 0x41, 0x87, 0xcc, 0xd8, 0xb6,
0x34, 0x8f, 0x30, 0x86, 0xd2, 0xd5, 0xba, 0xd8,
0xbc, 0x2f, 0x66, 0xe2, 0x6a, 0x36, 0x91, 0x5d,
0x68, 0xf9, 0x8a, 0x91, 0x47, 0x3e, 0x46, 0xc4,
0x93, 0xc9, 0xcf, 0xde, 0x9c, 0xfb, 0x36, 0xec,
0xbe, 0x5b, 0x1e, 0x2f, 0x1b, 0xd6, 0x99, 0x20,
0xbb, 0x4f, 0x54, 0x5a, 0x7b, 0x56, 0x9f, 0x96,
0xb4, 0x87, 0x3c, 0x08, 0x1f, 0xc0, 0x31, 0xa3,
0xfb, 0x74, 0x94, 0x01, 0x33, 0xfa, 0x3b, 0xc0,
0x0f, 0x7d, 0x55, 0x22, 0x23, 0x29, 0xa5, 0xb1,
0x52, 0x34, 0xb5, 0x85, 0x08, 0xff, 0xf2, 0xb4,
0xdd, 0x7a, 0xd0, 0xba, 0x65, 0xb1, 0x5f, 0x77,
0x23, 0xb3, 0xbf, 0x32, 0x7a, 0x47, 0x4d, 0x25,
0xf8, 0x08, 0x76, 0x46, 0x97, 0x82, 0x07, 0x06,
0x71, 0xcc, 0x68, 0x8f, 0x6d, 0x76, 0x26, 0x24,
0xf1, 0x32, 0xd4, 0xbe, 0x51, 0xd0, 0x4e, 0x7b,
0x64, 0xad, 0x50, 0x0e, 0xfc, 0x03, 0x49, 0xdc,
0x96, 0x11, 0x6b, 0x52, 0x53, 0x71, 0xd4, 0xc6,
0x17, 0x05, 0x15, 0x16, 0x4b, 0x9a, 0xb6, 0xa8,
0x27, 0x18, 0x6e, 0xae, 0x53, 0x6b, 0xba, 0xcd,
0x73, 0x58, 0x53, 0xda, 0x7a, 0x2b, 0x4d, 0x7b,
0xe0, 0x83, 0x4c, 0xac, 0x77, 0x8a, 0xda, 0x3c,
0x4a, 0xc9, 0x96, 0x6d, 0x40, 0xb1, 0x91, 0xe4,
0x1a, 0x5f, 0xbf, 0x88, 0xff, 0x72, 0xee, 0x56,
0x67, 0x22, 0xb8, 0x6d, 0x69, 0xfb, 0x18, 0x6f,
0x0f, 0x51, 0xf9, 0xaf, 0xee, 0x22, 0x31, 0x2a,
0x71, 0xf1, 0xae, 0x68, 0xb4, 0x97, 0xee, 0x27,
0x5a, 0x96, 0x08, 0x9d, 0x41, 0xf1, 0x7d, 0xb4,
0x55, 0xd1, 0xfa, 0x79, 0x2a, 0x4b, 0xbf, 0x3c,
0x35, 0xc9, 0xa1, 0x17, 0xf4, 0x99, 0x5d, 0xc8,
0x5d, 0x84, 0x76, 0x02, 0x65, 0xfe, 0xb8, 0xdd,
0xb2, 0x08, 0xc6, 0x15, 0x74, 0x59, 0xc9, 0x9a,
0x6b, 0xe3, 0xa6, 0xfb, 0xa1, 0xa7, 0x8e, 0x42,
0x5c, 0x7f, 0x5d, 0xca, 0xa2, 0xa3, 0xc3, 0x80,
0xdb, 0x36, 0x3e, 0xe2, 0x2d, 0xaa, 0x02, 0x29,
0x52, 0x08, 0x17, 0x67, 0x0e, 0x4d, 0x8d, 0xbc,
0x28, 0x7b, 0x0e, 0xde, 0x17, 0x9c, 0x0c, 0x9d,
0x13, 0x20, 0xaa, 0xfa, 0x59, 0x84, 0x7e, 0x25,
0x6e, 0xcb, 0x54, 0xe6, 0x50, 0xe5, 0xd3, 0xf5,
0xd0, 0x88, 0xb3, 0x7b, 0xf5, 0xa3, 0x16, 0x48,
0x36, 0x85, 0xbe, 0xda, 0xf7, 0x28, 0x8f, 0xc9,
0xb7, 0x0c, 0xdd, 0x6a, 0x15, 0xd1, 0x00, 0xa9,
0xa1, 0xdf, 0x73, 0x40, 0x6d, 0x55, 0xdb, 0xbe,
0xdc, 0x7e, 0xd7, 0x70, 0xd0, 0x59, 0xc0, 0xf4,
0x6c, 0xfb, 0x69, 0xb8, 0xa7, 0xa5, 0xe8, 0x89,
0x2c, 0xd4, 0x28, 0x8f, 0x2d, 0xb6, 0x60, 0x12,
0x80, 0x40, 0x15, 0xa8, 0xbf, 0xfb, 0x84, 0x1d,
0x97, 0x18, 0xba, 0x6e, 0xc5, 0xaf, 0x37, 0x0b,
0xbb, 0xe6, 0xbd, 0xb8, 0x19, 0xf6, 0x51, 0x13,
0xf9, 0x5e, 0xb9, 0xb0, 0x09, 0x53, 0xb9, 0x93,
0x6b, 0xb6, 0x9f, 0x71, 0x64, 0x84, 0xf2, 0x21,
0x4d, 0xc8, 0x3a, 0x85, 0xb3, 0xef, 0x61, 0x68,
0x80, 0x93, 0x33, 0x36, 0xef, 0x8b, 0x99, 0xb9,
0xf0, 0xe7, 0xb1, 0x52, 0x2b, 0xc1, 0x57, 0x1e,
0x3c, 0xf0, 0xba, 0x9b };
char peer1_2[] = { /* Packet 1143 */
0xce, 0xcc, 0xad, 0xe0, 0xa2, 0xde, 0x14, 0x6e,
0x8a, 0xb5, 0xe2, 0x46, 0xba, 0xca, 0x19, 0x67,
0x90, 0xdc, 0x43, 0xe0, 0x1e, 0x56, 0xee, 0x11,
0xa8, 0xff, 0xad, 0x51, 0xce, 0xa2, 0x87, 0x37,
0xa9, 0xb9, 0x80, 0x62, 0xfc, 0x88, 0xd9, 0x4f,
0xb7, 0x18, 0x1d, 0xb2, 0x6e, 0x23, 0x04, 0x0c,
0x02, 0x36, 0x54, 0x41, 0x61, 0x4e, 0x9f, 0x11,
0xd0, 0xdd, 0xa2, 0xa8, 0xec, 0xa9, 0xa1, 0x52,
0xaf, 0x32, 0xc9, 0x4d, 0x00, 0x8f, 0x4b, 0x66,
0xd1, 0xa0, 0x49, 0x63, 0xe9, 0x0d, 0xc3, 0x90,
0x30, 0xa4, 0xae, 0x50, 0x9b, 0x77, 0x8f, 0x92,
0x24, 0xd4, 0x29, 0x91, 0x5c, 0x1a, 0x43, 0x5a,
0x33, 0xe6, 0xd2, 0xfe, 0xf6, 0xbb, 0xdb, 0x9d,
0x21, 0xdc, 0x20, 0x78, 0x1b, 0x3c, 0xbb, 0xd6,
0xf7, 0x02, 0x4c, 0x12, 0x10, 0x98, 0xfd, 0xa9,
0x66, 0x00, 0x3c, 0xe9, 0x00, 0xc0, 0x50, 0x9b,
0x88, 0xe2, 0xba, 0x63, 0xcb, 0x03, 0xec, 0xd0,
0xa5, 0xf0, 0x61, 0x64, 0xfe, 0x51, 0x2c, 0x18,
0x3b, 0x45, 0x94, 0xa1, 0xcf, 0xc4, 0xa1, 0x5f,
0xcf, 0x8d, 0x87, 0x22, 0x89, 0x86, 0xb9, 0xf2,
0xe8, 0x99, 0x6c, 0x74, 0x8e, 0x01, 0x20, 0xc0,
0x7b, 0x15, 0x15, 0x2f, 0xcf, 0xe5, 0x28, 0x05,
0x85, 0xb9, 0x5d, 0xa4, 0x3a, 0xf1, 0xe9, 0x36,
0x61, 0xf5, 0x99, 0x71, 0xc2, 0x32, 0x18, 0x93,
0x64, 0x71, 0x7e, 0xad, 0x62, 0xaa, 0xea, 0xf2,
0x14, 0xaa, 0x95, 0x69, 0x55, 0xc9, 0x69, 0xc1,
0x18, 0x38, 0x75, 0x86, 0x05, 0x55, 0x93, 0xa0,
0xb3, 0x9f, 0xc0, 0x63, 0x86, 0x31, 0x93, 0x34,
0x8d, 0x6b, 0x04, 0x50, 0x62, 0xc9, 0x5f, 0xdb,
0xa4, 0xa0, 0x10, 0x37, 0x1a, 0x01, 0xa9, 0x24,
0xbe, 0x09, 0xcc, 0x3c, 0xa2, 0x84, 0x5e, 0xbf,
0x99, 0xf2, 0x57, 0x7f, 0x7b, 0x38, 0x6f, 0x9f,
0xca, 0xe0, 0xd8, 0x6e, 0xc5, 0xe8, 0x73, 0x65,
0x1c, 0xf1, 0xa8, 0x1e, 0x28, 0x5d, 0xec, 0x79,
0xa5, 0x97, 0x82, 0x9c, 0x0c, 0xc6, 0xe3, 0xea,
0xd7, 0x8f, 0x2c, 0x53, 0xa5, 0xea, 0x76, 0x0c,
0xbd, 0xd5, 0x6e, 0xeb, 0x59, 0xa2, 0x91, 0xb1,
0x62, 0xfe, 0x49, 0x2a, 0x20, 0xe9, 0x8b, 0x86,
0xc5, 0x76, 0x71, 0x1a, 0xeb, 0x98, 0x12, 0x65,
0x11, 0x4a, 0x6c, 0x98, 0x72, 0x5a, 0xd3, 0x9a,
0xaf, 0x93, 0x2b, 0xec, 0x37, 0x05, 0x8a, 0xb7,
0xd4, 0xfa, 0xe9, 0x9f, 0xd8, 0xfd, 0x1e, 0x0f,
0xe5, 0x29, 0xa1, 0x5b, 0xba, 0xb8, 0x42, 0x67,
0x7b, 0xf1, 0x1c, 0x2c, 0x3b, 0xef, 0xdc, 0x0a,
0x06, 0x72, 0x61, 0xe3, 0x59, 0x83, 0xc3, 0x36,
0x3f, 0xd2, 0xb9, 0x3f, 0x33, 0x97, 0xbe, 0x8c,
0xf1, 0xae, 0xfe, 0xaf, 0xf0, 0xc5, 0xf3, 0xb6,
0x88, 0x2a, 0x56, 0xd1, 0xcd, 0x0d, 0xa9, 0xb2,
0x02, 0x62, 0x20, 0x27, 0x7d, 0x2b, 0x52, 0x19,
0x00, 0x46, 0x83, 0xd3, 0x11, 0x03, 0xb4, 0x7e,
0x92, 0x58, 0xf5, 0x8b, 0xa2, 0x3e, 0x9e, 0x26,
0x31, 0x87, 0x44, 0xa6, 0xd3, 0x09, 0xc6, 0x3e,
0x55, 0xac, 0x5a, 0xbb, 0x3a, 0xf6, 0xc5, 0x08,
0x1c, 0x04, 0xfb, 0x47, 0x44, 0x78, 0xfb, 0x2d,
0x61, 0xf8, 0xcd, 0xe5, 0xef, 0x9d, 0xfb, 0x81,
0xd3, 0x98, 0xd2, 0x65, 0x7e, 0xff, 0x14, 0x24,
0xca, 0x8e, 0xe0, 0xcd, 0x9e, 0xaa, 0x06, 0x75,
0xd5, 0x88, 0x01, 0x62, 0xd6, 0x32, 0x41, 0x98,
0xa4, 0x4f, 0x96, 0x54, 0x86, 0x94, 0xfc, 0xbb,
0xe2, 0x4a, 0xf2, 0x64, 0x21, 0xa9, 0x79, 0x7d,
0x70, 0x11, 0x30, 0xd4, 0xc0, 0xd2, 0x6f, 0x11,
0x4f, 0x31, 0xf2, 0xcf, 0xf5, 0x02, 0xe9, 0x3c,
0x4e, 0xa3, 0xe2, 0x5b, 0xae, 0x9b, 0x73, 0x2d,
0xfc, 0x51, 0x1f, 0x8a, 0x83, 0x5c, 0x8d, 0x57,
0x42, 0xc9, 0xef, 0xaa, 0x22, 0x64, 0x9f, 0x2b,
0xfe, 0x25, 0x26, 0xcf, 0xdc, 0x38, 0xb9, 0x5e,
0xc7, 0xf2, 0xe3, 0x31, 0xf7, 0xdf, 0x47, 0xc8,
0xe6, 0x23, 0xe5, 0x0a, 0xb2, 0x6a, 0xb5, 0xb3,
0x07, 0xbc, 0x9b, 0xde, 0x55, 0x07, 0x6a, 0xcd,
0xa8, 0x70, 0x83, 0x83, 0x87, 0x89, 0x4e, 0xc1,
0xed, 0xc5, 0x74, 0xa8, 0xe9, 0x74, 0x4b, 0xe0,
0xcc, 0x85, 0x6c, 0xfc, 0x94, 0x2e, 0xac, 0x23,
0x69, 0x3a, 0xb7, 0xb2, 0xd0, 0xc4, 0xab, 0x53,
0xcb, 0xfb, 0xdf, 0x27, 0x2a, 0x9c, 0x48, 0xeb,
0x71, 0x3c, 0x25, 0x30, 0x0f, 0xf3, 0xa0, 0x96,
0xc9, 0x2c, 0xc4, 0xfe, 0x30, 0x7e, 0x10, 0xd7,
0xfd, 0xa6, 0x82, 0x08, 0x39, 0x73, 0xc8, 0x87,
0x85, 0x3e, 0x44, 0xdf, 0xe8, 0xe7, 0xf7, 0x6a,
0xeb, 0xef, 0x70, 0xa2, 0x46, 0x67, 0x31, 0x28,
0xeb, 0x91, 0x83, 0xda, 0x91, 0x22, 0x27, 0x63,
0xc7, 0x98, 0xcb, 0x76, 0x25, 0x51, 0x49, 0xeb,
0x17, 0x5d, 0x91, 0xc2, 0x5f, 0xae, 0xf4, 0xb7,
0xf5, 0xea, 0x6c, 0x50, 0x7e, 0x8c, 0x7e, 0xc2,
0x36, 0xc8, 0x72, 0x16, 0x08, 0x75, 0x6b, 0x75,
0x3e, 0xa5, 0xd8, 0x12, 0xbc, 0xbe, 0x3e, 0x28,
0x55, 0x36, 0x95, 0xd4, 0x0c, 0xa7, 0x45, 0x5c,
0xa3, 0xff, 0x44, 0x54, 0xcf, 0x94, 0x3b, 0x95,
0xe7, 0xe7, 0x1e, 0x8f, 0x5a, 0xd3, 0x81, 0x44,
0xe8, 0x25, 0x69, 0x59, 0xa5, 0xcd, 0x2d, 0x02,
0x2d, 0x77, 0x5e, 0x3a, 0x28, 0x25, 0xa9, 0xfd,
0x33, 0x14, 0xd2, 0x68, 0x0e, 0x02, 0xfb, 0xc9,
0xa3, 0x99, 0xba, 0xa5, 0x2f, 0xb5, 0xcf, 0x56,
0xb7, 0x52, 0x29, 0xa1, 0xe3, 0xb3, 0xd1, 0x9a,
0x7f, 0x8d, 0xba, 0x1d, 0xe3, 0x0a, 0x57, 0x1a,
0x30, 0x89, 0x23, 0x4f, 0xb5, 0xa7, 0x02, 0x9f,
0x1e, 0x5d, 0xf0, 0x4d, 0xf0, 0x18, 0xea, 0x0b,
0x21, 0xe3, 0xd0, 0xb5, 0x6f, 0xfd, 0xcd, 0x04,
0xb6, 0x52, 0xf1, 0xc8, 0x1a, 0x41, 0x84, 0x0d,
0xbf, 0x6c, 0xdf, 0x23, 0x5c, 0x16, 0x6f, 0x1e,
0x24, 0xe9, 0x76, 0x6d, 0xd3, 0x39, 0x89, 0x67,
0xe7, 0xc8, 0xd5, 0xfd, 0x8e, 0x9b, 0x57, 0xac,
0xab, 0x24, 0x1b, 0x53, 0xdc, 0x88, 0x5c, 0x16,
0x97, 0x1b, 0x84, 0x96, 0x6c, 0x05, 0xe8, 0xc4,
0xa3, 0x49, 0xe4, 0x18, 0x6e, 0xcd, 0x5d, 0x06,
0x6f, 0xb8, 0x3c, 0xd0, 0x72, 0x53, 0x9e, 0xda,
0x04, 0xfc, 0x66, 0x5c, 0xe2, 0x35, 0xd7, 0x4c,
0x85, 0x29, 0xab, 0x68, 0x6f, 0xdf, 0x61, 0xb4,
0x85, 0x27, 0xc4, 0xa7, 0x3b, 0x0a, 0x75, 0x3b,
0x68, 0x37, 0x56, 0xad, 0x6e, 0xe6, 0xad, 0x8c,
0xb3, 0xcd, 0x1c, 0x99, 0x51, 0x3d, 0xc3, 0x8e,
0x32, 0x5e, 0x0f, 0xca, 0x4a, 0x1f, 0xbb, 0x65,
0xf8, 0xcd, 0x21, 0xcb, 0x79, 0x03, 0x75, 0x6e,
0xde, 0xcc, 0x72, 0x8c, 0xa4, 0xb2, 0x2b, 0x42,
0x72, 0xdb, 0x87, 0xbf, 0xb2, 0xa4, 0xc3, 0xc4,
0x8b, 0xe5, 0xea, 0xdc, 0x75, 0xab, 0x1a, 0xfb,
0x16, 0xb6, 0x76, 0xf0, 0x05, 0x4f, 0x56, 0x2a,
0x39, 0x09, 0x00, 0xc8, 0xa2, 0xdd, 0x8c, 0x34,
0xfd, 0xe3, 0x17, 0x91, 0xdc, 0xab, 0x9e, 0x24,
0x28, 0xc8, 0x07, 0xff, 0x55, 0x79, 0xaa, 0xab,
0x1f, 0x14, 0xf3, 0xcd, 0xfa, 0x94, 0x2c, 0xed,
0xc4, 0xa8, 0x65, 0x61, 0x6e, 0x9d, 0x00, 0xde,
0xda, 0xb1, 0xe5, 0x6b, 0xcf, 0xd8, 0x41, 0x63,
0x27, 0x8c, 0x26, 0x38, 0xf2, 0x3a, 0x85, 0x3b,
0x8b, 0xe7, 0x8c, 0x5f, 0x7a, 0x18, 0x81, 0xfb,
0xe4, 0x0e, 0xec, 0xe2, 0xf8, 0xda, 0x05, 0x02,
0xa7, 0x6d, 0xd6, 0x09, 0xbb, 0x4f, 0xe5, 0x21,
0x25, 0x8d, 0xfa, 0x50, 0x74, 0xa0, 0xe9, 0xa0,
0xfe, 0xf8, 0xde, 0xe8, 0x8d, 0x1e, 0x40, 0x45,
0xdc, 0xf9, 0xdb, 0x36, 0x68, 0xad, 0xbb, 0x88,
0x9f, 0x94, 0x47, 0xcf, 0xdd, 0xe4, 0x19, 0x73,
0xee, 0x2d, 0x00, 0x30, 0x95, 0xdd, 0x26, 0x7a,
0xa8, 0x58, 0xe4, 0x98, 0x7e, 0x35, 0xf5, 0x40,
0xbb, 0xf1, 0xa5, 0xb4, 0xc2, 0xd4, 0x2e, 0x41,
0x25, 0x15, 0x8a, 0x5f, 0xf5, 0xd1, 0xb5, 0xcb,
0x19, 0x7a, 0xc6, 0xef, 0x30, 0xb0, 0x48, 0xe0,
0xc6, 0x30, 0x2b, 0x47, 0x72, 0x4c, 0x3d, 0x05,
0x76, 0x34, 0x80, 0x4d, 0xd9, 0x19, 0x72, 0x6f,
0xac, 0x90, 0x0d, 0xc0, 0x8a, 0x0f, 0x49, 0xda,
0xb7, 0xab, 0xb3, 0x6c, 0xeb, 0x46, 0xff, 0x85,
0x8e, 0x46, 0xf2, 0x20, 0xee, 0x83, 0x89, 0x2e,
0xc1, 0x7a, 0x27, 0x0e, 0xb4, 0x1b, 0x51, 0x98,
0x1c, 0x35, 0x90, 0xdc, 0x04, 0xeb, 0x38, 0xc2,
0x2b, 0x1c, 0xaa, 0x50, 0x1f, 0xc4, 0xa2, 0xdb,
0xae, 0xcb, 0x3c, 0x40, 0x04, 0xf4, 0x9a, 0x10,
0xb6, 0x79, 0x3c, 0xc5, 0x56, 0x99, 0x10, 0xd8,
0x51, 0x19, 0x51, 0x87, 0x05, 0x33, 0x4d, 0xa8,
0x2f, 0xd0, 0xac, 0xc5, 0x66, 0x61, 0xa5, 0x58,
0xdc, 0x65, 0xa9, 0x70, 0x63, 0x90, 0x7c, 0xd9,
0xf7, 0x4e, 0x2d, 0xfb, 0xe5, 0x74, 0x5e, 0xd5,
0x9e, 0xff, 0x0a, 0x9a, 0x9b, 0xe9, 0xd9, 0x07,
0x74, 0x75, 0xfa, 0x42, 0xa2, 0xcf, 0xf7, 0xcd,
0x41, 0x1d, 0x64, 0x1f, 0xb5, 0x31, 0xd0, 0x08,
0x20, 0xa7, 0x32, 0xcf, 0xcd, 0xc5, 0x23, 0x85,
0xbe, 0x5f, 0x2a, 0x38, 0x21, 0x0e, 0xc2, 0xbb,
0x3f, 0x35, 0xbd, 0xf4, 0x1c, 0xc8, 0x1f, 0x6a,
0xeb, 0xc1, 0xcb, 0xd9, 0x5e, 0x5f, 0x2a, 0x85,
0x69, 0xfc, 0x94, 0x1e, 0xe6, 0x62, 0x1b, 0xa6,
0x88, 0xf3, 0xa3, 0xd2, 0x0c, 0xf0, 0xd0, 0xee,
0x18, 0x93, 0x8f, 0x52, 0xee, 0x7b, 0x73, 0x02,
0xb3, 0x53, 0x78, 0x73, 0x9b, 0x30, 0xed, 0x92,
0x29, 0xbf, 0x9d, 0xd5, 0xcd, 0xbe, 0x51, 0x0f,
0xed, 0x35, 0x00, 0x4d, 0xdf, 0x92, 0xfe, 0x8f,
0x51, 0xec, 0xab, 0xbb, 0x72, 0x7e, 0x41, 0x3e,
0xf1, 0x1f, 0x44, 0x8f, 0x0d, 0x17, 0xce, 0x75,
0xdf, 0x56, 0xc5, 0xe5, 0x96, 0xbd, 0xaa, 0x36,
0xb8, 0x24, 0x32, 0x44, 0x3a, 0x55, 0xb8, 0xe8,
0xcd, 0x6b, 0x40, 0xc7, 0x01, 0xe3, 0x8b, 0x1e,
0x0c, 0x0c, 0xe6, 0x61, 0x80, 0xd6, 0xe2, 0xf2,
0xa4, 0xec, 0x77, 0x95, 0xac, 0x83, 0xf3, 0x10,
0x75, 0xc0, 0xa9, 0xb4, 0x0d, 0x66, 0xaf, 0xc5,
0x6f, 0xd8, 0x10, 0xe8, 0x5c, 0xfd, 0x53, 0xb0,
0xe1, 0x84, 0xb0, 0x26, 0xab, 0x3d, 0xe7, 0xe3,
0x17, 0x70, 0x49, 0x4b, 0x4c, 0x0e, 0xaa, 0xdc,
0x43, 0xfe, 0xa1, 0xf1, 0x8a, 0xb5, 0x1e, 0xc4,
0xb9, 0xc8, 0xfb, 0xd9, 0x40, 0xa0, 0x66, 0xab,
0xdf, 0x9a, 0x08, 0x9b, 0x10, 0x87, 0x11, 0xcb,
0x9c, 0x46, 0xb5, 0x0b, 0x2b, 0x5e, 0x86, 0xff,
0xb6, 0x8f, 0x51, 0xe5, 0x9a, 0x08, 0x31, 0xf1,
0xaf, 0x51, 0xf8, 0x8a, 0x81, 0x20, 0x71, 0x81,
0x85, 0x3d, 0x0e, 0xbd, 0x45, 0x26, 0xf4, 0x7b,
0x0b, 0x0c, 0xca, 0x6f, 0xfe, 0x79, 0xa7, 0xae,
0x87, 0x90, 0xe4, 0x7e, 0x03, 0x9c, 0xcf, 0x09,
0x20, 0x34, 0x6a, 0x56 };
char peer1_3[] = { /* Packet 1144 */
0xec, 0x43, 0x8f, 0x32, 0xd5, 0x30, 0x4c, 0x93,
0x2d, 0x0d, 0xbd, 0xbe, 0x03, 0x01, 0xad, 0xbf,
0xd3, 0x22, 0x3e, 0xf3, 0x38, 0x79, 0xb2, 0x11,
0xb1, 0x35, 0xb5, 0x2e, 0xbe, 0x26, 0x28, 0x65,
0x29, 0x28, 0xcf, 0x9c, 0x58, 0x89, 0xe4, 0x1a,
0x79, 0xb8, 0xc1, 0xc4, 0xa9, 0xc3, 0xcf, 0x02,
0x94, 0xd0, 0x8d, 0xcc, 0xa9, 0x97, 0x92, 0xfb,
0x23, 0x0a, 0x68, 0xee, 0x91, 0x61, 0x4d, 0x6e,
0x90, 0xf9, 0x34, 0x80, 0xbe, 0x93, 0x5e, 0x44,
0xa2, 0x71, 0x70, 0xc6, 0x1f, 0x58, 0xcb, 0xcd,
0xbf, 0xdd, 0xcb, 0x86, 0xe2, 0x06, 0x22, 0x6f,
0x0a, 0xed, 0x39, 0xa2, 0xf8, 0xd6, 0x58, 0x19,
0xae, 0x54, 0xa7, 0x2a, 0xf8, 0x5b, 0xb5, 0xc2,
0x71, 0x5c, 0xc2, 0x50, 0x62, 0x73, 0xf9, 0xe0,
0x1e, 0x76, 0x6b, 0xef, 0x49, 0x21, 0xe1, 0x02,
0xbb, 0x28, 0xed, 0xef, 0x06, 0x06, 0xaa, 0x26,
0xee, 0x8e, 0xdd, 0xc3, 0x58, 0x82, 0x38, 0xb2,
0x41, 0xc3, 0x19, 0x54, 0x2c, 0xd1, 0x2e, 0xc5,
0xa1, 0x2a, 0x84, 0xc5, 0x1d, 0xe9, 0x36, 0xd1,
0x83, 0x95, 0xee, 0x63, 0x94, 0x7d, 0x3e, 0xcb,
0xc3, 0xcc, 0xd3, 0x96, 0xbf, 0x04, 0x38, 0xe6,
0xf8, 0x14, 0x35, 0x56, 0x34, 0x53, 0x8b, 0x64,
0x52, 0x0e, 0xea, 0x87, 0xeb, 0xdd, 0x77, 0x91,
0x6f, 0x95, 0xf1, 0xcc, 0xf8, 0xdd, 0x4b, 0x09,
0x0c, 0x8b, 0x78, 0x6a, 0xc4, 0xf3, 0x18, 0x3e,
0x3d, 0x8b, 0x44, 0x17, 0x19, 0x5a, 0xf5, 0x39,
0x19, 0xc6, 0xdf, 0x82, 0xa2, 0x81, 0x19, 0x9a,
0x5f, 0x6d, 0xfe, 0x6b, 0x6f, 0x37, 0x41, 0x62,
0x38, 0xfd, 0x02, 0xfe, 0x7f, 0xfa, 0x15, 0x0a,
0x69, 0xa4, 0x7e, 0x15, 0x46, 0x88, 0x16, 0xc8,
0x9d, 0x4c, 0x59, 0x5f, 0xbf, 0x0b, 0x79, 0xc8,
0x62, 0xcc, 0x47, 0x9d, 0x01, 0x55, 0x1c, 0x9b,
0x01, 0x8f, 0x3e, 0xe3, 0xec, 0x2b, 0x70, 0xdb,
0xcc, 0x24, 0xf5, 0x85, 0x03, 0xa7, 0xa3, 0x15,
0xb1, 0xe9, 0xc8, 0x06, 0x29, 0xb1, 0x0f, 0xde,
0x3f, 0xc2, 0xeb, 0x40, 0x81, 0xab, 0x62, 0x3d,
0x33, 0xb2, 0x73, 0x26, 0x4f, 0x6b, 0xe9, 0x29,
0x57, 0x21, 0xf6, 0x14, 0x4f, 0x1d, 0x0b, 0x0c,
0x08, 0x03, 0xf2, 0x1a, 0x44, 0x21, 0x3b, 0x86,
0x55, 0xdc, 0x90, 0x03, 0xd8, 0xa3, 0x34, 0x34,
0xa9, 0xe7, 0x79, 0x14, 0x60, 0xc3, 0x3f, 0x7b,
0x4f, 0x16, 0x48, 0xfc, 0xd6, 0x4a, 0x1a, 0x46,
0xfb, 0xb2, 0x1b, 0xca, 0xb8, 0x42, 0xd6, 0x9e,
0x21, 0xdb, 0x20, 0x97, 0xce, 0xdf, 0xf0, 0xc8,
0xa6, 0xeb, 0x69, 0x6c, 0x82, 0xbc, 0x84, 0x19,
0x0a, 0x4a, 0x13, 0x48, 0x2a, 0x3b, 0xda, 0xaa,
0xd3, 0xa9, 0xa3, 0x79, 0x4d, 0x44, 0x84, 0xe8,
0xc3, 0x90, 0x00, 0xc0, 0x0f, 0x11, 0xe4, 0x86,
0x7f, 0x17, 0x5c, 0x1d, 0xa4, 0x25, 0xb7, 0xb9,
0x1f, 0xee, 0x70, 0x46, 0xa6, 0x20, 0xf4, 0xb1,
0x1b, 0x9f, 0x25, 0x13, 0x07, 0x60, 0x0a, 0x0e,
0xe1, 0xf6, 0xad, 0x64, 0x36, 0xeb, 0x7d, 0x48,
0xb5, 0x20, 0x23, 0xf5, 0x03, 0xb6, 0x20, 0xb7,
0xdb, 0x3f, 0x52, 0x18, 0x19, 0x3f, 0x11, 0x67,
0xdd, 0x29, 0x78, 0x88, 0x0c, 0x3a, 0x0c, 0x7d,
0xa1, 0xed, 0xc3, 0x1c, 0x9f, 0xa6, 0x06, 0x57,
0x9e, 0x91, 0x7e, 0xb9, 0xf0, 0x41, 0x8c, 0x19,
0xe2, 0x8e, 0xc9, 0x65, 0x68, 0x2b, 0xa5, 0x81,
0xc7, 0x10, 0xe0, 0xc9, 0xbc, 0x6e, 0x2d, 0x5e,
0xe6, 0xf1, 0x03, 0x8c, 0x97, 0x57, 0xb9, 0x67,
0x05, 0x94, 0xa7, 0x4d, 0x56, 0xfc, 0x5d, 0xc3,
0x13, 0x92, 0x2c, 0xf2, 0x13, 0x2e, 0x66, 0x85,
0x53, 0xdc, 0x99, 0x32, 0xdd, 0x9d, 0x9b, 0x12,
0x27, 0x4a, 0xee, 0xe1, 0xa9, 0xca, 0x8f, 0x2c,
0x48, 0x49, 0xf9, 0x04, 0x65, 0x8d, 0x98, 0x3a,
0xe1, 0x94, 0x97, 0x2d, 0x07, 0x6c, 0x74, 0x86,
0xbf, 0x65, 0x7d, 0xed, 0xa8, 0x0a, 0xb3, 0xd4,
0x2f, 0xd8, 0x68, 0x9f, 0x60, 0xbf, 0x75, 0xaf,
0x9d, 0xf3, 0xc9, 0x57, 0xbd, 0xac, 0x0f, 0x33,
0x9f, 0xd0, 0x2b, 0xf2, 0x3d, 0xa7, 0x20, 0xec,
0xa2, 0x8d, 0x01, 0x37, 0x2a, 0x76, 0xaf, 0xa3,
0x72, 0x16, 0x3a, 0xf7, 0xbf, 0xa3, 0xad, 0x85,
0xbc, 0x59, 0xfc, 0x0b, 0x03, 0xb4, 0x7f, 0x45,
0x44, 0xa4, 0x87, 0xa9, 0xa5, 0x4b, 0xea, 0x3f,
0xcf, 0x7c, 0xab, 0x09, 0x0b, 0xe8, 0xfa, 0x48,
0x3e, 0xad, 0xdd, 0x56, 0x31, 0x80, 0x7f, 0x93,
0x3f, 0x4f, 0xdf, 0xc2, 0x15, 0xba, 0xe4, 0x80,
0xac, 0x07, 0x5c, 0xb6, 0x0f, 0x44, 0x6d, 0xf8,
0x80, 0x93, 0x37, 0xc1, 0xfd, 0xe7, 0x1f, 0x55,
0xcc, 0x1e, 0x79, 0xbc, 0x57, 0x01, 0xde, 0x15,
0x41, 0xfe, 0xc0, 0xa4, 0x16, 0x48, 0xf6, 0xeb,
0x0c, 0xb3, 0x21, 0x27, 0x4f, 0xd3, 0x42, 0x02,
0xdd, 0x98, 0x6f, 0x3b, 0x56, 0xfa, 0x52, 0x45,
0x84, 0x0f, 0x56, 0x72, 0x65, 0xab, 0x11, 0x3c,
0x8f, 0xde, 0x07, 0x8c, 0x3e, 0x59, 0x4a, 0x2b,
0x3b, 0x67, 0x5f, 0xc8, 0x37, 0xd8, 0xba, 0x5f,
0x48, 0xf5, 0xb9, 0x91, 0x29, 0xbc, 0x6d, 0x13,
0xc8, 0x71, 0x41, 0x5e, 0xca, 0xd8, 0x05, 0x02,
0xff, 0x94, 0x30, 0x05, 0xce, 0x95, 0x3a, 0xd5,
0xf1, 0x35, 0xaf, 0x9c, 0x48, 0x27, 0x3a, 0x7b,
0x81, 0xfe, 0x9f, 0xdf, 0xa8, 0xec, 0x97, 0x94,
0xaa, 0xd0, 0xab, 0x7b, 0x0b, 0x9a, 0x8c, 0x95,
0xea, 0xd7, 0x40, 0xbc, 0x8c, 0x2f, 0x28, 0xe3,
0xea, 0xff, 0x48, 0x18, 0xc4, 0x91, 0x6d, 0x86,
0xca, 0xa0, 0xa7, 0x57, 0xff, 0x17, 0xe7, 0xd1,
0x95, 0xb4, 0x07, 0xcc, 0x37, 0x7a, 0x94, 0x4a,
0x63, 0xae, 0x4e, 0x8f, 0x89, 0xb2, 0xfd, 0xca,
0x45, 0x82, 0x82, 0xdc, 0xc7, 0x5a, 0x6f, 0xde,
0x58, 0x27, 0xb7, 0xa9, 0x49, 0xaa, 0xe1, 0x15,
0xd4, 0x5a, 0xe0, 0x69, 0x91, 0xdf, 0x9b, 0x9d,
0x6a, 0x78, 0x5b, 0x1a, 0x29, 0x25, 0x63, 0xd8,
0x16, 0xc8, 0xe3, 0x58, 0x59, 0xf5, 0x21, 0x80,
0x26, 0x1c, 0xd9, 0xdb, 0x07, 0x5d, 0x24, 0x70,
0x88, 0x9a, 0xc8, 0x00, 0x26, 0xf9, 0xb2, 0x92,
0xfb, 0xe7, 0x65, 0x06, 0x6b, 0x28, 0x63, 0xf7,
0xbd, 0x02, 0xe9, 0xa9, 0x6f, 0x7d, 0xca, 0x1f,
0x79, 0x93, 0xbd, 0x43, 0x9e, 0x95, 0x89, 0x2c,
0x07, 0x61, 0x96, 0x88, 0x22, 0x35, 0xc4, 0x34,
0x22, 0x1f, 0xde, 0x74, 0xeb, 0x07, 0xd6, 0x86,
0xad, 0xde, 0x51, 0x00, 0xf2, 0xc5, 0xe3, 0xef,
0xac, 0xbb, 0xfb, 0x95, 0x18, 0x04, 0x6b, 0x33,
0x17, 0xea, 0x6f, 0x78, 0x39, 0x6c, 0x96, 0x6f,
0x6e, 0xfe, 0x64, 0xba, 0xac, 0x40, 0x63, 0xb1,
0x97, 0x32, 0x5b, 0xee, 0xf2, 0x40, 0x54, 0xb2,
0x31, 0xa7, 0x6d, 0xd8, 0xdb, 0x80, 0x5d, 0x1e,
0x3f, 0x42, 0x0f, 0x95, 0x33, 0x0f, 0xbe, 0x20,
0xd5, 0x15, 0xe1, 0x94, 0x04, 0x45, 0x6a, 0xa4,
0x24, 0xf2, 0x58, 0x61, 0x41, 0x18, 0xa5, 0x02,
0xc2, 0xb6, 0x29, 0xd4, 0xaa, 0x9d, 0x7a, 0xb8,
0xda, 0x61, 0x62, 0x57, 0x6c, 0x03, 0x5a, 0x7d,
0x5b, 0xd6, 0xb1, 0xef, 0x14, 0x27, 0x9c, 0x18,
0x07, 0x85, 0xbc, 0xbe, 0x82, 0x41, 0x64, 0x5e,
0xf9, 0x47, 0xb2, 0x5c, 0x41, 0x27, 0x6c, 0xee,
0x5d, 0x7e, 0x91, 0x09, 0x48, 0xc1, 0x9d, 0xaa,
0x3e, 0x82, 0xcb, 0x53, 0xa7, 0x38, 0x81, 0x06,
0x16, 0xc7, 0x0f, 0x0c, 0xad, 0x96, 0x0b, 0x22,
0x03, 0x97, 0x84, 0xfd, 0x02, 0x38, 0xec, 0x9c,
0x71, 0x30, 0x43, 0xfa, 0x41, 0xc8, 0xcf, 0xfd,
0x22, 0x39, 0xd7, 0xcd, 0x7e, 0x79, 0x00, 0x4b,
0x1c, 0x40, 0xa3, 0x66, 0x23, 0x69, 0xf3, 0x9e,
0x5d, 0x85, 0xf7, 0xcf, 0x9f, 0xee, 0x08, 0x95,
0x75, 0x27, 0x4b, 0x86, 0xde, 0xad, 0x54, 0x9c,
0x4c, 0x6a, 0x5d, 0x94, 0x09, 0x34, 0x58, 0x11,
0x3c, 0x25, 0x0d, 0x7a, 0x90, 0xed, 0x2e, 0x7b,
0xee, 0xfe, 0x43, 0x6b, 0x58, 0xe5, 0x59, 0x65,
0x29, 0xe8, 0x22, 0x90, 0x33, 0xab, 0x59, 0x6d,
0x5f, 0xf4, 0xf0, 0x61, 0xba, 0x05, 0xaf, 0xf3,
0xb4, 0xe6, 0xb9, 0x29, 0x0b, 0xf2, 0xf7, 0xee,
0x92, 0xab, 0x4c, 0x7c, 0x63, 0xf7, 0x8f, 0xe0,
0x1e, 0x4e, 0x6c, 0x43, 0xbf, 0x07, 0x09, 0x9f,
0x61, 0x86, 0xc0, 0x3b, 0x2d, 0xf9, 0x2e, 0x1d,
0x85, 0xcb, 0x19, 0xe3, 0xf3, 0xb3, 0xaf, 0x97,
0x8d, 0x8c, 0x42, 0x8a, 0xd3, 0x64, 0x1e, 0xbb,
0x48, 0x78, 0x43, 0x3f, 0x89, 0xa5, 0xa8, 0x6e,
0x1d, 0x21, 0x6c, 0xbc, 0x3e, 0x3c, 0xdb, 0xc0,
0x5f, 0xda, 0x2d, 0x3c, 0xa4, 0xd2, 0xa0, 0xd4,
0x07, 0x55, 0x0f, 0x91, 0x38, 0x2d, 0x49, 0xa5,
0x62, 0x34, 0x1f, 0x26, 0xc9, 0xab, 0x1c, 0x84,
0x90, 0xb2, 0xce, 0xe1, 0x37, 0x37, 0x2b, 0x05,
0x79, 0x5f, 0x8a, 0x6d, 0x6f, 0xb1, 0xe5, 0xea,
0x00, 0xd4, 0x27, 0x19, 0x7f, 0xd2, 0x41, 0xb8,
0x33, 0x45, 0xd1, 0x33, 0x04, 0x69, 0x16, 0x22,
0x6b, 0x0f, 0xaa, 0x74, 0x0f, 0x61, 0x90, 0x53,
0x71, 0x45, 0x6c, 0xce, 0xb7, 0x14, 0x9c, 0x53,
0x2e, 0x20, 0xf5, 0xd9, 0x1b, 0x0c, 0xf3, 0xd5,
0x00, 0xfc, 0x2a, 0x0d, 0xfa, 0xbd, 0x3f, 0x4f,
0xb7, 0xa1, 0x7b, 0x38, 0x2d, 0x46, 0x84, 0xd6,
0x63, 0x90, 0x05, 0x45, 0xb6, 0xd8, 0x20, 0x1a,
0x25, 0x78, 0x37, 0x62, 0x78, 0x77, 0x74, 0x5b,
0x14, 0x4c, 0xfe, 0x52, 0x11, 0xd4, 0x5e, 0xcc,
0x82, 0xb0, 0xd7, 0x1d, 0xe1, 0x02, 0xed, 0x23,
0xb8, 0xa8, 0x20, 0xc6, 0x48, 0x60, 0x87, 0xba,
0x40, 0x20, 0x06, 0xfd, 0x8f, 0xdb, 0xe3, 0x12,
0x3d, 0xd9, 0x51, 0x97, 0xf8, 0xc6, 0x68, 0x98,
0x09, 0x0d, 0xff, 0x37, 0xec, 0x53, 0x61, 0x91,
0x6b, 0x86, 0xdb, 0xe6, 0x3a, 0xd9, 0x07, 0x0a,
0xff, 0x87, 0xaf, 0xd1, 0xbe, 0xfd, 0xa0, 0x44,
0xf7, 0x77, 0xba, 0x95, 0xcd, 0x69, 0xd9, 0xad,
0x1c, 0x85, 0x79, 0xea, 0x30, 0x7d, 0x8f, 0x19,
0x20, 0xfb, 0x23, 0x3d, 0xca, 0xd1, 0xeb, 0x5a,
0x4a, 0x2d, 0x38, 0x1c, 0x7b, 0xc9, 0x70, 0x7e,
0x68, 0x32, 0x99, 0x9f, 0x9d, 0x06, 0x89, 0xaf,
0xfd, 0x5c, 0x32, 0x80, 0x7f, 0x83, 0xfe, 0x24,
0xae, 0xe2, 0xbe, 0x01, 0x65, 0xf5, 0x5c, 0xea,
0xc4, 0x36, 0x66, 0x83, 0x48, 0x53, 0x3e, 0x51,
0x47, 0x59, 0x26, 0x61, 0xd0, 0xa3, 0x1f, 0x13,
0xdb, 0x85, 0x65, 0xc3, 0x33, 0x75, 0x41, 0x88,
0x15, 0xb3, 0x45, 0xbe, 0x51, 0xf2, 0x10, 0x82,
0x0f, 0x83, 0x92, 0x57, 0x68, 0xc9, 0x1b, 0x31,
0x30, 0x69, 0x03, 0x1f, 0x08, 0xb4, 0x9d, 0x87,
0x1b, 0xd0, 0x59, 0x40, 0x2d, 0xd3, 0x84, 0x2e,
0xac, 0x79, 0xa2, 0x6e, 0xda, 0x71, 0x18, 0x38,
0x8a, 0x20, 0x47, 0xa8 };
char peer1_4[] = { /* Packet 1145 */
0x76, 0x4d, 0x8d, 0xac, 0xe3, 0xe7, 0x21, 0xb6,
0x12, 0x5e, 0xc4, 0xa1, 0x30, 0x4d, 0xd0, 0x8d,
0x56, 0x9e, 0x6c, 0x1d, 0xe3, 0x9b, 0x9e, 0x51,
0xc8, 0xf3, 0xe6, 0xfe, 0x1d, 0x06, 0x50, 0x72,
0x55, 0x00, 0x49, 0x5f, 0xb5, 0xfe, 0x22, 0x08,
0x57, 0xe4, 0x1e, 0x08, 0xd4, 0x18, 0x48, 0x89,
0x09, 0x19, 0xe8, 0xd6, 0x4f, 0x4d, 0x20, 0xef,
0x94, 0xf6, 0x15, 0x9d, 0x0d, 0xd1, 0xb6, 0x05,
0x78, 0x2b, 0x6d, 0x63, 0x8d, 0x34, 0x24, 0xe7,
0xd3, 0x90, 0xb2, 0x10, 0x7f, 0x04, 0xcd, 0xc1,
0x71, 0x5b, 0x28, 0xdc, 0x79, 0xcf, 0xb2, 0x29,
0x57, 0xdf, 0x3c, 0xbd, 0xbe, 0x8e, 0x1e, 0x93,
0xb4, 0x94, 0x51, 0xa3, 0x47, 0xcb, 0xb3, 0xed,
0x3c, 0x6b, 0xbf, 0x4a, 0xf8, 0x74, 0x46, 0xb7,
0xc0, 0xc8, 0xe4, 0x98, 0x09, 0xb6, 0x7e, 0xde,
0xd7, 0x42, 0x65, 0x27, 0x3d, 0x0f, 0x5b, 0x1f,
0xf5, 0x1c, 0x52, 0x34, 0xda, 0xfd, 0x1d, 0x19,
0x43, 0x64, 0xa3, 0x0a, 0xf4, 0x57, 0x2f, 0x91,
0xce, 0xf6, 0xcf, 0x03, 0x69, 0xcf, 0x3f, 0xf0,
0xe8, 0xef, 0xbb, 0x29, 0x49, 0x35, 0xa9, 0x44,
0x87, 0x95, 0x59, 0x2b, 0x84, 0x79, 0xcf, 0xdb,
0xf7, 0x31, 0xcd, 0x26, 0xf6, 0xbd, 0x11, 0x0d,
0x1b, 0x62, 0x57, 0x82, 0xc6, 0xe7, 0x36, 0x68,
0xcb, 0xa3, 0xed, 0x78, 0xf3, 0x10, 0x17, 0x91,
0x20, 0xb5, 0x70, 0x80, 0x1a, 0x17, 0xd0, 0xd7,
0xba, 0xee, 0x22, 0x68, 0xde, 0x96, 0xcd, 0xd0,
0x83, 0x72, 0xa1, 0x25, 0xb6, 0x9e, 0xa6, 0xe4,
0x2c, 0x92, 0x13, 0x4c, 0x94, 0x6f, 0x55, 0x6f,
0xbc, 0x25, 0xb0, 0xc9, 0x12, 0x2a, 0x1b, 0x87,
0x3e, 0xfd, 0xb0, 0xa8, 0x2a, 0x11, 0xa0, 0x44,
0x90, 0x86, 0x39, 0x92, 0x55, 0xc0, 0xbb, 0x0e,
0xc5, 0x38, 0x9e, 0xd1, 0x54, 0x30, 0xc0, 0x10,
0xe2, 0xa5, 0x24, 0xa4, 0x4d, 0x54, 0x40, 0x8e,
0xbe, 0x79, 0xc6, 0x0f, 0x26, 0x01, 0x96, 0x5c,
0x18, 0xfc, 0x4a, 0x4b, 0x9c, 0xe7, 0xe1, 0x7d,
0x45, 0x66, 0x42, 0x30, 0x2f, 0xa3, 0xde, 0x8e,
0x02, 0xc7, 0xf1, 0x19, 0x6f, 0x29, 0x7b, 0x50,
0xdb, 0xbf, 0x8b, 0x26, 0x1c, 0x52, 0xee, 0xec,
0x92, 0x58, 0x6a, 0x01, 0x82, 0xe3, 0x7b, 0x9d,
0xd3, 0xef, 0x72, 0xd2, 0xf2, 0xeb, 0x87, 0x32,
0x88, 0x00, 0x8d, 0x71, 0xce, 0xe1, 0x47, 0xf7,
0xb1, 0x3e, 0x96, 0x8a, 0x5d, 0x75, 0x69, 0xfb,
0x00, 0xfb, 0x47, 0xe2, 0xe4, 0xe3, 0x2e, 0xbb,
0x26, 0xeb, 0x13, 0x2e, 0x74, 0x03, 0x9b, 0xf2,
0xee, 0x96, 0xa9, 0x46, 0xc9, 0xa8, 0x5c, 0xa6,
0x08, 0x6e, 0x61, 0x38, 0xf4, 0x0f, 0x24, 0xa1,
0x8d, 0x35, 0x59, 0x18, 0xe7, 0x19, 0xed, 0x6f,
0x41, 0xdc, 0x28, 0x85, 0x42, 0x13, 0xd6, 0xae,
0xda, 0x1e, 0xb2, 0x8c, 0x31, 0x0a, 0x78, 0xe7,
0x76, 0x4e, 0x38, 0x0e, 0x03, 0x30, 0xb7, 0xe4,
0x97, 0x49, 0x9d, 0xca, 0x92, 0x73, 0x97, 0x58,
0x3c, 0x90, 0x5a, 0x07, 0xd0, 0x75, 0xc7, 0x4f,
0x1e, 0x58, 0xa3, 0x02, 0x56, 0xb1, 0xf9, 0x86,
0xa9, 0xd3, 0xf8, 0xc6, 0xc8, 0xd7, 0x0e, 0x9d,
0xa7, 0xe1, 0xcc, 0x6c, 0x15, 0xee, 0x2d, 0xc2,
0x27, 0x3d, 0x21, 0xb5, 0x82, 0x1e, 0x6d, 0xf0,
0xcb, 0x3a, 0x72, 0xdc, 0x5a, 0x6f, 0x76, 0x22,
0x42, 0xd7, 0x97, 0xc6, 0x04, 0x54, 0x14, 0xf6,
0xb1, 0x92, 0x6c, 0x69, 0xdc, 0x27, 0xb7, 0xcd,
0x62, 0x98, 0xee, 0x10, 0x0e, 0x9c, 0xa8, 0xd4,
0x3e, 0xdf, 0x5a, 0xc1, 0xcd, 0xe7, 0x21, 0xa9,
0x82, 0x17, 0xaa, 0x04, 0x9a, 0x1b, 0x22, 0x90,
0x82, 0x08, 0x28, 0x0a, 0x5d, 0xaa, 0xb4, 0x2c,
0xbe, 0x10, 0x5c, 0xfd, 0x32, 0x77, 0x76, 0x97,
0x1e, 0xa2, 0xc8, 0xa6, 0xca, 0xe3, 0xfb, 0x51,
0x46, 0xc3, 0xef, 0xe6, 0x9b, 0x5d, 0x83, 0x43,
0x04, 0x6e, 0xad, 0x48, 0x39, 0x58, 0x64, 0xb9,
0x57, 0xba, 0xd1, 0xa2, 0x5e, 0x90, 0xf7, 0x80,
0x15, 0xba, 0x78, 0x32, 0x35, 0x20, 0x3c, 0xcb,
0xcc, 0x1f, 0xc4, 0x18, 0xa4, 0x4e, 0x15, 0x81,
0x69, 0x5e, 0xeb, 0xae, 0x39, 0x7e, 0x87, 0xf2,
0x82, 0x22, 0x29, 0xa6, 0xf0, 0xc4, 0x61, 0xca,
0x01, 0x7a, 0x7f, 0xfe, 0x86, 0xd2, 0x39, 0x33,
0x1b, 0x4f, 0x30, 0xd3, 0xdd, 0x16, 0x64, 0xf6,
0x50, 0xb3, 0x6f, 0x8e, 0x42, 0xb1, 0xfc, 0x73,
0x8b, 0x68, 0xf0, 0xfe, 0x14, 0x13, 0x92, 0x21,
0x4d, 0xfd, 0xa0, 0x11, 0x3c, 0x25, 0x16, 0x33,
0x3f, 0xca, 0xec, 0x42, 0xd8, 0xbe, 0xbf, 0xc8,
0x32, 0x17, 0xad, 0xac, 0x32, 0x4c, 0x7d, 0x7a,
0xc0, 0x34, 0x8f, 0xcc, 0xc1, 0x4d, 0x29, 0x4b,
0x3b, 0x08, 0x7a, 0x6b, 0x36, 0x7b, 0x25, 0x7c,
0xed, 0x60, 0x55, 0x0d, 0xcf, 0x8b, 0x76, 0x39,
0x8d, 0xba, 0x50, 0xe6, 0xc9, 0x58, 0x80, 0xbd,
0x9d, 0xf0, 0x62, 0x1a, 0x4e, 0xae, 0xa0, 0xea,
0xa2, 0xe8, 0x8d, 0x42, 0x50, 0x62, 0x0c, 0x1c,
0xbd, 0xa5, 0xa1, 0xf6, 0x9d, 0x10, 0x49, 0xf2,
0x8d, 0xc4, 0x3f, 0xf3, 0x1c, 0xc0, 0xce, 0x18,
0x25, 0x71, 0xe2, 0xe5, 0xa6, 0x46, 0x79, 0x2e,
0x21, 0x53, 0xd9, 0xe1, 0xd7, 0x83, 0x3f, 0x57,
0x54, 0x32, 0x75, 0xe1, 0x29, 0x22, 0x8c, 0xa2,
0x74, 0xe1, 0x07, 0x0d, 0xb3, 0x48, 0x51, 0x83,
0x0a, 0x17, 0xf3, 0x75, 0x68, 0x5b, 0xa9, 0x8f,
0xef, 0x06, 0xc2, 0xda, 0xb4, 0xde, 0xad, 0xe4,
0x9e, 0xed, 0x75, 0x13, 0xa5, 0xfd, 0xe3, 0xc8,
0x35, 0x87, 0x62, 0xf9, 0x1c, 0x80, 0x1a, 0x15,
0x07, 0xd8, 0x6b, 0xc6, 0x6d, 0xa2, 0x1a, 0x0f,
0xf6, 0x2d, 0x11, 0xfc, 0x65, 0x35, 0x96, 0xa6,
0xb4, 0x5b, 0x9d, 0x18, 0x9d, 0x8d, 0xd2, 0x6d,
0x65, 0x86, 0xf8, 0xae, 0x88, 0x7f, 0x81, 0xbc,
0x3a, 0xc3, 0xc5, 0x6f, 0xb0, 0x6f, 0x33, 0x7f,
0xcc, 0xc5, 0x29, 0xf1, 0x9c, 0x9c, 0x04, 0xd9,
0xee, 0x67, 0x51, 0x1f, 0xab, 0xe2, 0x3c, 0xaf,
0xaa, 0x85, 0x9c, 0xd1, 0xf8, 0x37, 0xca, 0x35,
0x77, 0x26, 0xa5, 0x5e, 0x1e, 0xf6, 0x39, 0xbb,
0xe7, 0xe0, 0x3e, 0xe1, 0x4f, 0x55, 0xf4, 0x29,
0xbb, 0x64, 0xc9, 0x7b, 0x21, 0x37, 0x15, 0xa9,
0xde, 0x6b, 0x64, 0x54, 0xb6, 0xb4, 0xf8, 0xc1,
0x0a, 0x87, 0x96, 0xa0, 0x8d, 0xc1, 0xa6, 0x2c,
0xea, 0x3a, 0xdf, 0x26, 0x90, 0xb0, 0x96, 0x01,
0x67, 0xaa, 0xda, 0x33, 0x7d, 0x4e, 0x6a, 0x83,
0x2e, 0xee, 0xcb, 0x07, 0xef, 0x9e, 0xfa, 0xac,
0x37, 0x5b, 0xa3, 0xb3, 0x9c, 0xab, 0x23, 0x3d,
0x6a, 0x02, 0x3c, 0x3e, 0x79, 0x05, 0x36, 0x2f,
0xbd, 0x7a, 0xc1, 0xc9, 0x6b, 0xf2, 0x5f, 0x24,
0x22, 0x9e, 0xe9, 0x24, 0xe7, 0x09, 0x79, 0xc0,
0xea, 0xe2, 0xa1, 0x11, 0xbb, 0x02, 0xc1, 0xa8,
0x36, 0x3b, 0xf8, 0x7b, 0x0b, 0x94, 0xd0, 0x2b,
0xdc, 0xb3, 0x4b, 0x13, 0xdf, 0x8a, 0xd4, 0xcb,
0x4d, 0x0d, 0x4e, 0xc8, 0x77, 0xb3, 0x1d, 0x93,
0xfa, 0x0f, 0xd5, 0x0f, 0x38, 0xa6, 0x81, 0x11,
0x43, 0x5c, 0xc8, 0xef, 0x19, 0xff, 0x55, 0x38,
0x20, 0x64, 0x3c, 0x59, 0xec, 0x4c, 0xf8, 0x81,
0x89, 0x11, 0x3f, 0x01, 0xa3, 0xf5, 0xce, 0xf6,
0x56, 0x82, 0x41, 0xa5, 0x09, 0xda, 0x45, 0x9f,
0xcf, 0xff, 0xe8, 0x8e, 0xa6, 0x55, 0xad, 0x08,
0xed, 0x7e, 0xa9, 0xe1, 0x7c, 0x52, 0x19, 0xf0,
0x72, 0x65, 0x52, 0x3d, 0x60, 0xcb, 0x7f, 0xe5,
0xee, 0xa0, 0x95, 0x9c, 0x6d, 0xd8, 0xcd, 0xfa,
0xfd, 0x20, 0x38, 0xf1, 0x33, 0x5c, 0xa8, 0x1d,
0x6e, 0xea, 0x8e, 0x87, 0xe6, 0x98, 0x73, 0x1d,
0xb8, 0xd7, 0x88, 0xec, 0xdd, 0x54, 0x94, 0x5f,
0x84, 0x53, 0x83, 0x68, 0x08, 0x75, 0xe9, 0x70,
0xc2, 0x31, 0x8f, 0x1a, 0x77, 0x6a, 0xea, 0x0e,
0x71, 0x86, 0x3a, 0x26, 0x12, 0x28, 0x71, 0x4a,
0x29, 0x02, 0x12, 0xd4, 0x19, 0x85, 0xf2, 0x42,
0x0d, 0x22, 0x31, 0x71, 0x33, 0xa7, 0xc1, 0x79,
0x41, 0x46, 0x6b, 0x3d, 0x52, 0x17, 0x65, 0x0e,
0xd7, 0x9b, 0xb4, 0x04, 0xdf, 0x96, 0x8f, 0x0f,
0x46, 0x75, 0xb8, 0x58, 0x69, 0x4e, 0x5e, 0x95,
0x50, 0xe7, 0x41, 0xea, 0x83, 0x5c, 0x7b, 0x58,
0xc5, 0x51, 0xc0, 0xf4, 0xdd, 0xb2, 0xa2, 0x4c,
0x11, 0xf0, 0x61, 0x0a, 0xab, 0x3b, 0xa6, 0x27,
0x73, 0x24, 0x92, 0xe4, 0x32, 0xf4, 0x6d, 0xb2,
0x21, 0xee, 0x4f, 0x0d, 0x20, 0x89, 0x53, 0x33,
0xaf, 0x78, 0x9e, 0x6c, 0xdd, 0xa1, 0xea, 0x4e,
0x95, 0xaf, 0x57, 0x6d, 0x4a, 0xe6, 0x64, 0x6c,
0xa8, 0xa1, 0xe1, 0x11, 0x25, 0xd7, 0x19, 0x13,
0xcc, 0x48, 0xaa, 0x75, 0x87, 0xc6, 0x05, 0x28,
0xeb, 0x3b, 0xde, 0x38, 0x65, 0x0e, 0x30, 0x4b,
0x8d, 0x33, 0xcf, 0x73, 0xb2, 0xf8, 0x17, 0x54,
0xf0, 0x96, 0x9f, 0xf2, 0x25, 0x4c, 0xce, 0x56,
0x21, 0x10, 0x0a, 0xef, 0x15, 0xac, 0xd9, 0x1a,
0x10, 0xf3, 0xae, 0xc3, 0xc5, 0xbc, 0xdf, 0xef,
0x73, 0xd5, 0x20, 0xd8, 0x31, 0x22, 0x60, 0x3a,
0xc3, 0xe3, 0x95, 0x6f, 0x93, 0x90, 0xe8, 0x0d,
0x5f, 0x0c, 0xee, 0x85, 0xfb, 0xda, 0xd3, 0xad,
0x70, 0xbc, 0x02, 0x53, 0xed, 0xe6, 0xec, 0x71,
0x63, 0x16, 0x18, 0x81, 0x61, 0x67, 0x50, 0x6b,
0xd5, 0x83, 0xbc, 0x8f, 0xeb, 0x7f, 0x93, 0x92,
0x4e, 0x5d, 0x6c, 0x19, 0x09, 0x55, 0x2a, 0xf7,
0x64, 0x91, 0x99, 0x16, 0xda, 0xad, 0xbd, 0x02,
0x72, 0xb7, 0xc4, 0x48, 0xb5, 0x70, 0xd3, 0x4a,
0x0f, 0x3a, 0x22, 0x41, 0x38, 0xd2, 0x06, 0xa5,
0x20, 0x69, 0xdc, 0xb3, 0xb8, 0x74, 0xcb, 0xc5,
0xed, 0x42, 0x5f, 0x3e, 0x61, 0x07, 0xc2, 0x96,
0x17, 0x4b, 0xc2, 0x1f, 0x1f, 0xf7, 0xad, 0x47,
0xb9, 0xd7, 0x2f, 0x9b, 0x95, 0xd6, 0x0b, 0x97,
0xfb, 0xd7, 0xf4, 0x34, 0xf6, 0x3d, 0x88, 0xfa,
0xf5, 0x5f, 0xe5, 0x6a, 0x2c, 0xfb, 0x74, 0x66,
0x01, 0x96, 0x73, 0x46, 0xf0, 0xf8, 0x86, 0x29,
0x14, 0x5e, 0x30, 0x7f, 0x48, 0x3d, 0x3c, 0xb1,
0xde, 0xa3, 0x4d, 0x73, 0x53, 0xda, 0xd4, 0x8f,
0xf8, 0xda, 0x7e, 0x12, 0x17, 0x8a, 0xae, 0xbc,
0x45, 0xb8, 0xa1, 0xe8, 0xc0, 0x8b, 0x7b, 0xe5,
0xae, 0xe7, 0xf4, 0x09, 0xf9, 0x83, 0xfa, 0x86,
0xfa, 0xc8, 0xd9, 0xf5, 0x22, 0x0d, 0x2f, 0xc5,
0xc4, 0xac, 0xb0, 0x85, 0xee, 0xf3, 0x80, 0x97,
0xe3, 0x02, 0xee, 0x3c, 0x8b, 0x31, 0xe0, 0x3c,
0x27, 0xa0, 0x72, 0xdc, 0x08, 0xfb, 0x4e, 0xeb,
0x75, 0xa9, 0xf5, 0x77, 0x09, 0xa6, 0xdb, 0xb3,
0xab, 0xca, 0x1e, 0xbf, 0x2d, 0xf2, 0x74, 0x7a,
0x30, 0x71, 0x9d, 0xc9, 0x4e, 0x91, 0x78, 0x8c,
0x35, 0xda, 0x9e, 0xf1 };
char peer1_5[] = { /* Packet 1146 */
0xd5, 0x76, 0x98, 0x10, 0x46, 0x3f, 0xb8, 0x3a,
0xff, 0xec, 0xa4, 0x71, 0xa2, 0xbb, 0x14, 0xdc,
0x76, 0x03, 0xa1, 0x6b, 0xa9, 0x59, 0xd8, 0x66,
0xed, 0x3f, 0x6b, 0x46, 0xe2, 0x3b, 0x15, 0xf7,
0xfc, 0xac, 0x1d, 0x2d, 0xce, 0x9c, 0x2b, 0x38,
0x53, 0x87, 0x6c, 0x03, 0xd1, 0x50, 0x0d, 0xcb,
0xa1, 0xde, 0xbb, 0x63, 0x71, 0x60, 0x6f, 0x40,
0x49, 0xc5, 0x68, 0xd2, 0x9b, 0x8d, 0x2b, 0xd4,
0xad, 0x7c, 0x9e, 0x18, 0xb2, 0xdc, 0x8a, 0xb7,
0x3d, 0x33, 0xbf, 0x5c, 0x90, 0x11, 0xfe, 0x6d,
0xd6, 0x9a, 0xa7, 0x55, 0x87, 0xf9, 0xda, 0xe9,
0x24, 0xa8, 0x42, 0x38, 0x06, 0x61, 0x48, 0x34,
0xa0, 0x09, 0xe8, 0x90, 0x9c, 0x12, 0xf0, 0xdf,
0x22, 0xe4, 0x12, 0xac, 0x18, 0x56, 0xfd, 0x38,
0x81, 0xfe, 0xdd, 0xf9, 0xa1, 0x21, 0xab, 0x20,
0x27, 0x25, 0x0f, 0x24, 0x9c, 0x2d, 0x04, 0xdb,
0xe5, 0x25, 0x20, 0xfa, 0xda, 0xfe, 0xc6, 0x8f,
0xf1, 0x99, 0x29, 0xe1, 0xd1, 0x32, 0x7b, 0x54,
0xe5, 0x01, 0xca, 0xad, 0xed, 0xcd, 0x4f, 0xb6,
0xd0, 0xdd, 0xfa, 0x70, 0xa0, 0xd4, 0x9f, 0x07,
0xb6, 0xd0, 0xc1, 0x09, 0x79, 0x29, 0x51, 0x48,
0x57, 0x5c, 0x7b, 0x3b, 0x6e, 0x45, 0x3b, 0xb3,
0xf5, 0xeb, 0x63, 0x47, 0xa4, 0xd4, 0x10, 0x71,
0x27, 0xf4, 0x2b, 0x8d, 0xc7, 0x16, 0xfd, 0xc9,
0xd7, 0x60, 0x96, 0x33, 0x22, 0x41, 0xc1, 0x5e,
0xbc, 0xaa, 0x83, 0xd0, 0x1f, 0xc1, 0x7b, 0x4f,
0x55, 0xe9, 0x91, 0x7e, 0x9e, 0x01, 0x2d, 0x78,
0x13, 0xdc, 0xff, 0x77, 0x61, 0x51, 0x15, 0x55,
0x61, 0xa2, 0xb3, 0xe8, 0x21, 0x7a, 0x7c, 0x72,
0xb0, 0xcb, 0x55, 0xec, 0xa3, 0x49, 0x00, 0x70,
0x2b, 0xdb, 0x8e, 0xe4, 0x3a, 0xbc, 0x70, 0x54,
0x2d, 0x34, 0x8a, 0x72, 0xd6, 0xb3, 0x3e, 0x12,
0xaf, 0x82, 0xc1, 0x21, 0x83, 0x67, 0xa6, 0x8d,
0xe6, 0x93, 0xf1, 0x12, 0x61, 0xe4, 0xff, 0x8d,
0xbc, 0xb8, 0x17, 0xa9, 0x72, 0x55, 0xb7, 0x7c,
0x32, 0xa6, 0x8b, 0xc3, 0x7a, 0xef, 0x57, 0xb5,
0x59, 0x4a, 0xc9, 0x1c, 0xee, 0xfd, 0x78, 0xf6,
0x87, 0x32, 0x02, 0x1c, 0xd3, 0xdd, 0x6b, 0x9e,
0xa1, 0x06, 0xd8, 0x00, 0xbd, 0xe8, 0xe4, 0xe1,
0x27, 0x43, 0xba, 0x71, 0x86, 0x38, 0xda, 0x5b,
0xb5, 0x01, 0xf2, 0x4d, 0x93, 0x3f, 0xc8, 0xd4,
0xaa, 0xb4, 0x2a, 0x79, 0x59, 0x5b, 0xc0, 0x14,
0xb3, 0xe6, 0x1a, 0x0d, 0x4e, 0x77, 0x9f, 0xfb,
0x67, 0x1e, 0x12, 0x71, 0x16, 0x07, 0x06, 0xd6,
0x1c, 0xb1, 0x78, 0x9d, 0xf5, 0xe7, 0x46, 0xa4,
0x22, 0xaf, 0x89, 0xd6, 0x8d, 0x17, 0xc7, 0xe0,
0x7e, 0xd0, 0x83, 0xd2, 0xa0, 0x17, 0x6a, 0xc1,
0x4f, 0xef, 0x6a, 0xe2, 0x62, 0xfe, 0xbd, 0x8b,
0x70, 0x8c, 0x77, 0xf0, 0xd7, 0x4d, 0x25, 0x93,
0xb1, 0xf8, 0xd7, 0x46, 0xd6, 0x14, 0x87, 0x21,
0x11, 0x44, 0x5f, 0xa6, 0x7e, 0xb7, 0x83, 0x75,
0x14, 0x2f, 0x77, 0xb1, 0xdf, 0x6b, 0x23, 0xbe,
0x4f, 0x14, 0xc2, 0x60, 0x78, 0x47, 0xf5, 0xc7,
0x4c, 0x5b, 0xd8, 0x4f, 0xe4, 0xb4, 0xbf, 0xc3,
0xbc, 0xae, 0x11, 0x1d, 0x22, 0xe8, 0xf3, 0x59,
0xde, 0x47, 0x5a, 0x9f, 0x39, 0xd0, 0x63, 0x7c,
0xa0, 0x55, 0x49, 0xed, 0xcb, 0xaa, 0xa0, 0xd0,
0x16, 0xf4, 0xaa, 0x0b, 0x16, 0x06, 0xd6, 0x15,
0x27, 0x3a, 0xe8, 0x85, 0x6f, 0x14, 0x9d, 0x76,
0x41, 0x2e, 0xb5, 0x2d, 0x7d, 0x4e, 0x09, 0xf3,
0x94, 0x6f, 0xd9, 0xc9, 0x1e, 0x68, 0x9f, 0xc7,
0x32, 0x97, 0x10, 0x1d, 0x31, 0x87, 0x36, 0x02,
0xfe, 0x75, 0x36, 0x12, 0x92, 0x2d, 0x99, 0xea,
0xc3, 0x62, 0x1d, 0xf7, 0x72, 0x72, 0x44, 0x27,
0x13, 0xf3, 0xdb, 0x25, 0x9a, 0x8c, 0x54, 0x5f,
0xb5, 0x72, 0x75, 0xb8, 0xaf, 0x9b, 0x9a, 0x38,
0xf4, 0x06, 0x7d, 0x9b, 0x52, 0xe0, 0x26, 0x1b,
0x23, 0x8f, 0xf2, 0x5d, 0x2b, 0x49, 0xef, 0xb5,
0x41, 0x3b, 0x16, 0xbc, 0x2a, 0x17, 0x31, 0x92,
0xff, 0xb1, 0x0f, 0x30, 0x7b, 0x1c, 0x94, 0x8b,
0x49, 0x0d, 0x05, 0xa3, 0xb9, 0x59, 0x10, 0x57,
0xc3, 0xe3, 0x76, 0xb0, 0x57, 0x6f, 0xb0, 0x70,
0x4a, 0x0f, 0x8f, 0xea, 0x83, 0x8a, 0xf4, 0xcc,
0xb4, 0x29, 0x5b, 0xc3, 0x61, 0x8b, 0x81, 0xda,
0x43, 0x5f, 0xfb, 0x4d, 0x61, 0x6c, 0xb0, 0xd9,
0x07, 0xb5, 0x81, 0x46, 0x03, 0x6f, 0xbd, 0x21,
0x96, 0xbf, 0xa4, 0xea, 0xae, 0xaf, 0x35, 0x26,
0x3f, 0x8f, 0x67, 0x70, 0xdc, 0x4a, 0x6e, 0x41,
0x99, 0xe1, 0xb0, 0x5e, 0xad, 0x43, 0x8a, 0x86,
0xed, 0xd7, 0x22, 0xf7, 0x08, 0xb3, 0x5e, 0x96,
0x12, 0xd5, 0x05, 0xa1, 0x9b, 0x11, 0xbf, 0xad,
0xe8, 0x6d, 0xdc, 0xed, 0x83, 0x6b, 0xfb, 0xd0,
0xab, 0xbe, 0x72, 0x81, 0x3e, 0x90, 0x98, 0x13,
0x0c, 0x0a, 0xe3, 0x40, 0x46, 0xd6, 0x73, 0x5f,
0x59, 0x99, 0x2b, 0x87, 0x37, 0x84, 0x65, 0x4a,
0xc5, 0x4a, 0xd9, 0x87, 0x84, 0x01, 0x3b, 0x10,
0xa4, 0xe9, 0x25, 0xe4, 0x02, 0x65, 0xa2, 0x80,
0xbf, 0x9d, 0x4a, 0x52, 0x26, 0x83, 0x22, 0xce,
0xda, 0x0d, 0x1f, 0x16, 0x39, 0x4f, 0xcb, 0x00,
0x3e, 0xdf, 0x23, 0xa3, 0xdf, 0xc0, 0xd3, 0x2d,
0x88, 0x89, 0xb4, 0x3b, 0x5c, 0x2e, 0x66, 0x26,
0x76, 0x9a, 0x2e, 0xc1, 0x8b, 0xdf, 0x7c, 0x95,
0x7b, 0x8e, 0x52, 0x06, 0xe7, 0xae, 0xcd, 0x5a,
0x0f, 0x28, 0x92, 0x14, 0x58, 0x6c, 0x8c, 0xf6,
0x54, 0x33, 0x40, 0x05, 0xd4, 0x7b, 0xfa, 0xbc,
0x0f, 0xae, 0x87, 0xfe, 0x50, 0xd0, 0xa7, 0x53,
0x13, 0xfc, 0x9a, 0x22, 0xde, 0x94, 0x0d, 0x72,
0x00, 0x2c, 0x4c, 0x91, 0xb4, 0x82, 0x0e, 0xdb,
0x24, 0xda, 0x81, 0xc7, 0x59, 0xec, 0x2d, 0x5d,
0xb3, 0x9c, 0x07, 0x94, 0x47, 0xbf, 0x3c, 0xbc,
0xc6, 0xfc, 0x36, 0x4c, 0xfb, 0x2d, 0x1d, 0xfc,
0x72, 0xcf, 0x97, 0x5b, 0xfd, 0xe8, 0x17, 0xce,
0x16, 0x93, 0xf3, 0x29, 0x27, 0xda, 0x6d, 0x93,
0x78, 0xc6, 0x31, 0x51, 0x49, 0xb6, 0xaf, 0x56,
0xc5, 0xfb, 0x6e, 0xc2, 0x24, 0x1d, 0x01, 0x3b,
0x82, 0xbe, 0x79, 0xd0, 0x76, 0xc8, 0x50, 0xe9,
0xac, 0x5e, 0xa2, 0x78, 0xe9, 0xb3, 0x18, 0xaf,
0x4f, 0x90, 0xe7, 0x4d, 0xf4, 0xbb, 0x8d, 0x42,
0x73, 0x65, 0xeb, 0xbe, 0xfd, 0x75, 0x00, 0xcc,
0xcf, 0x3c, 0xd8, 0x5e, 0x36, 0x24, 0x2d, 0xd1,
0x4d, 0xe9, 0x0b, 0x08, 0x11, 0x16, 0x63, 0xb1,
0x39, 0x1c, 0x68, 0x7c, 0x5d, 0x41, 0x04, 0x1c,
0x05, 0x84, 0x8a, 0x89, 0x0d, 0x12, 0x51, 0x96,
0x76, 0xb2, 0xcf, 0x06, 0xd0, 0xa8, 0x63, 0x86,
0x4b, 0x8d, 0x1c, 0xe1, 0xc3, 0xe4, 0x6a, 0x5d,
0x23, 0xa5, 0x98, 0xc8, 0xa3, 0x63, 0xb5, 0x83,
0x23, 0xc3, 0xa2, 0xac, 0x72, 0xdd, 0x82, 0xd2,
0x3e, 0xd8, 0xf3, 0xe8, 0x88, 0xca, 0x32, 0x17,
0xd8, 0xcc, 0x4d, 0xdd, 0xd3, 0x20, 0x37, 0x8f,
0x74, 0x5c, 0xc6, 0x72, 0xde, 0x04, 0x8b, 0x8b,
0x41, 0x19, 0xcc, 0x77, 0x92, 0x38, 0x4f, 0x3c,
0x6b, 0x33, 0x7e, 0xa4, 0xfc, 0x82, 0xea, 0x02,
0x5b, 0x50, 0x98, 0xf4, 0x26, 0x4e, 0x6f, 0xbd,
0x92, 0x53, 0x72, 0x3c, 0xed, 0x29, 0x2c, 0xf3,
0xba, 0x2a, 0x94, 0x69, 0xd1, 0x92, 0xc8, 0x09,
0xde, 0x24, 0xbe, 0x4a, 0xe5, 0x0c, 0x6c, 0xbe,
0x76, 0xef, 0x28, 0x9d, 0xc5, 0xe7, 0x85, 0xbb,
0xfe, 0xbc, 0x77, 0xd3, 0x99, 0x96, 0x66, 0xc3,
0x1b, 0x00, 0x05, 0xc5, 0xc3, 0x3d, 0x53, 0xb1,
0x78, 0x36, 0x73, 0x1f, 0x6f, 0x9d, 0xc1, 0x3a,
0x98, 0x85, 0xf6, 0x65, 0x2e, 0x59, 0x44, 0xcf,
0xb8, 0x53, 0xc0, 0x38, 0xfd, 0xd7, 0x4a, 0x9b,
0x41, 0xe4, 0xe9, 0x9d, 0xb6, 0x8e, 0x15, 0xf2,
0x15, 0x2c, 0x55, 0xe7, 0xc2, 0xd1, 0xed, 0x12,
0x4d, 0x95, 0x29, 0x10, 0xa5, 0x07, 0x5e, 0xcf,
0x5c, 0x95, 0x63, 0x3b, 0xa2, 0x8b, 0xf0, 0xd9,
0x6e, 0x58, 0x63, 0x18, 0xde, 0x5c, 0xfc, 0x69,
0xd8, 0x38, 0x66, 0x5c, 0x72, 0x33, 0x78, 0xfd,
0x87, 0x39, 0xd3, 0xca, 0x0d, 0xb4, 0x80, 0xc6,
0xfe, 0x9a, 0xfe, 0x61, 0x93, 0x4e, 0x91, 0x90,
0x34, 0x7e, 0x09, 0x6b, 0xf2, 0x67, 0xf2, 0x79,
0x92, 0xcb, 0x6b, 0x1b, 0x10, 0xb3, 0x3b, 0x2d,
0x8f, 0x55, 0xd9, 0xe1, 0x54, 0xea, 0x7b, 0x36,
0x67, 0x91, 0xcf, 0xd2, 0x6f, 0x25, 0xaa, 0xad,
0xa1, 0x8e, 0x2b, 0x16, 0xdd, 0xef, 0x21, 0xe3,
0x9d, 0xb1, 0x5e, 0xaf, 0xaa, 0xd8, 0x62, 0x45,
0xd1, 0x7f, 0x90, 0xb3, 0x8c, 0x34, 0x0d, 0x80,
0x6b, 0xef, 0x62, 0x98, 0x42, 0xab, 0x87, 0x09,
0xae, 0x9c, 0xc5, 0xa6, 0x09, 0x40, 0x04, 0x87,
0xa0, 0x14, 0xba, 0xd6, 0x59, 0x5b, 0xf7, 0xbd,
0xc5, 0xb1, 0xc4, 0x35, 0x8b, 0xe6, 0x47, 0x83,
0x32, 0xf4, 0x94, 0xfd, 0x39, 0xd7, 0x46, 0xc6,
0x37, 0xfa, 0x7c, 0x5f, 0x9a, 0xaf, 0x3e, 0xb4,
0xa0, 0xb4, 0x43, 0x07, 0x46, 0xa7, 0xbb, 0xee,
0x36, 0xd6, 0x28, 0x06, 0xf3, 0x22, 0xf6, 0xcd,
0xbe, 0x3a, 0x97, 0x28, 0x6e, 0x76, 0xb1, 0x43,
0xc6, 0xc7, 0xb8, 0x86, 0xa2, 0x5b, 0xe1, 0xf6,
0x65, 0x3a, 0x30, 0x46, 0x90, 0x67, 0x88, 0x83,
0x8f, 0xdb, 0xa0, 0x68, 0xe5, 0x3f, 0x14, 0x76,
0xbc, 0x6e, 0x7d, 0x70, 0x8f, 0x33, 0x35, 0xfe,
0xeb, 0xb3, 0x81, 0xe3, 0x26, 0x1c, 0x30, 0x86,
0xb0, 0x1f, 0x19, 0x1e, 0xdc, 0x73, 0x50, 0x3b,
0xe5, 0xb3, 0x52, 0xbe, 0x64, 0xd2, 0x09, 0x4e,
0xa5, 0x4d, 0x2a, 0x8c, 0xf0, 0xa9, 0xfe, 0xac,
0x2b, 0xde, 0x54, 0x93, 0x99, 0xd8, 0x71, 0xa1,
0x6d, 0x6d, 0xff, 0xb5, 0x97, 0x3f, 0x0c, 0xfe,
0x02, 0x95, 0xfb, 0x9c, 0xee, 0xfb, 0x5b, 0xc2,
0xd7, 0x05, 0xb8, 0x3c, 0xcd, 0x09, 0x13, 0xe3,
0xea, 0x70, 0xee, 0x5c, 0x60, 0x9e, 0x57, 0xe1,
0x4d, 0x70, 0x26, 0xc2, 0xa3, 0x5a, 0x5c, 0x90,
0xc4, 0x53, 0xb6, 0x83, 0x7f, 0x3e, 0x5c, 0x37,
0xe9, 0x6a, 0xbb, 0x91, 0x69, 0x92, 0x40, 0xb5,
0x5b, 0x15, 0xbf, 0xc6, 0x6b, 0xd3, 0xce, 0xd5,
0x7c, 0xa7, 0x97, 0x37, 0x49, 0xbe, 0x30, 0xa2,
0xc0, 0x21, 0xf7, 0x1d, 0x57, 0x0a, 0x49, 0x51,
0x0d, 0x6a, 0xfa, 0x50, 0x03, 0xd6, 0x29, 0x08,
0x83, 0x9a, 0xf4, 0x46, 0x87, 0x1c, 0xa9, 0x6f,
0x27, 0x01, 0x2c, 0x6c, 0x98, 0x1c, 0x3a, 0x9e,
0xbd, 0xe6, 0xe0, 0xa9, 0x23, 0x6c, 0x45, 0x1d,
0x87, 0x03, 0xac, 0xae, 0xfe, 0x7a, 0x6c, 0x7d,
0xcb, 0x43, 0xad, 0xd7, 0xcd, 0x66, 0x62, 0xe6,
0xe4, 0x37, 0x4f, 0xff, 0x9a, 0xf0, 0x35, 0x77,
0xaa, 0x20, 0x9f, 0x4c };
char peer1_6[] = { /* Packet 1147 */
0xd2, 0x60, 0x34, 0xd8, 0x85, 0x24, 0xbe, 0xa9,
0x3f, 0x00, 0xbd, 0x23, 0xde, 0x0a, 0xa7, 0x08,
0x95, 0xe5, 0x91, 0xc7, 0x27, 0x6f, 0x6c, 0x42,
0xaf, 0x0c, 0xd1, 0xfd, 0x57, 0x1f, 0x1d, 0xbb,
0x62, 0x8d, 0x1f, 0x0f, 0x8b, 0xbe, 0xaf, 0x1f,
0xa0, 0x59, 0x2e, 0x65, 0xf0, 0x02, 0x81, 0x1d,
0x4c, 0x13, 0x5f, 0x7c, 0x13, 0x2d, 0x6f, 0x37,
0x68, 0x73, 0x1a, 0xd9, 0xc2, 0xf5, 0x1f, 0xbf,
0xe8, 0x63, 0xb1, 0x8e, 0x45, 0x3e, 0xc0, 0x13,
0x16, 0x64, 0xbc, 0x10, 0x6b, 0x16, 0xcd, 0xfd,
0xb6, 0xc5, 0xe8, 0xe6, 0x0b, 0x30, 0x3f, 0xd3,
0xf4, 0xd8, 0xcf, 0x20, 0x76, 0x72, 0x2e, 0x65,
0xb3, 0x87, 0xcd, 0x94, 0xc7, 0xa9, 0x53, 0x47,
0x8c, 0xef, 0xe8, 0xb6, 0x1f, 0x66, 0x8e, 0x58,
0xb7, 0xa8, 0x7f, 0x8c, 0xbe, 0x5f, 0x14, 0x4f,
0x98, 0xe2, 0x07, 0x15, 0x40, 0x66, 0x2d, 0x92,
0xe4, 0xb3, 0xcb, 0x76, 0x6f, 0xa1, 0xd6, 0x63,
0x1d, 0x03, 0x35, 0xbd, 0xd5, 0x79, 0x26, 0xb5,
0x19, 0xde, 0xf8, 0xcf, 0x7e, 0xe4, 0x70, 0xd2,
0xe1, 0xf3, 0x15, 0xe5, 0x19, 0x50, 0xf7, 0xc8,
0x89, 0x09, 0x9e, 0x52, 0x7e, 0x19, 0x5f, 0x23,
0x56, 0xf4, 0xd2, 0xf7, 0x48, 0xe9, 0xcb, 0x47,
0x09, 0x12, 0x9b, 0x22, 0xe2, 0x5a, 0x83, 0xc2,
0x49, 0x28, 0x12, 0x41, 0x25, 0x31, 0x42, 0xf1,
0xe8, 0xf0, 0xb4, 0xa2, 0x74, 0x61, 0x6f, 0x29,
0xaa, 0x88, 0x81, 0xf5, 0x3f, 0x5b, 0xba, 0x6d,
0x0d, 0x7c, 0x71, 0x22, 0x28, 0xc1, 0x61, 0x0c,
0x4b, 0x73, 0x2b, 0xac, 0x53, 0x7c, 0xc3, 0xe6,
0x6b, 0xa8, 0xa4, 0xa8, 0x94, 0xf2, 0xb9, 0x1d,
0x92, 0xda, 0xdb, 0x7e, 0x91, 0x79, 0x4b, 0x02,
0xa6, 0xcd, 0x21, 0xb2, 0xaa, 0x78, 0x8a, 0x65,
0x9f, 0xd9, 0xb0, 0x48, 0xc3, 0x7c, 0xfd, 0x6f,
0x5c, 0xf9, 0x4f, 0xbd, 0x30, 0x8d, 0x7e, 0x9b,
0xe2, 0x67, 0xbb, 0xc5, 0x94, 0x46, 0xf9, 0x3e,
0x39, 0x8c, 0x40, 0xf0, 0xa6, 0x0b, 0x80, 0xda,
0x76, 0x47, 0x85, 0xc1, 0x94, 0xe3, 0xe7, 0x42,
0x19, 0x46, 0xb1, 0x7f, 0x34, 0x47, 0xe0, 0x50,
0xe2, 0x62, 0x75, 0x95, 0x8c, 0xb3, 0xb6, 0x4b,
0xea, 0x16, 0xe3, 0x74, 0xb3, 0x09, 0xde, 0xbb,
0xa8, 0xca, 0xba, 0x4b, 0xbb, 0x70, 0xb5, 0xdc,
0x80, 0xeb, 0x03, 0x8a, 0x60, 0x9e, 0x42, 0x0a,
0x7e, 0xaf, 0x5e, 0x28, 0xbf, 0xf2, 0xae, 0x90,
0x8d, 0xda, 0x81, 0xbc, 0x1f, 0x74, 0x25, 0x06,
0x56, 0xd7, 0x72, 0xd9, 0x18, 0x66, 0x98, 0xb4,
0x85, 0x1f, 0xb1, 0x4b, 0xfc, 0x14, 0x44, 0x3c,
0x4a, 0x8d, 0xca, 0x58, 0x3e, 0x64, 0x01, 0x26,
0xf7, 0xbd, 0xa0, 0xaf, 0x95, 0xbb, 0x18, 0x2c,
0xe6, 0xf6, 0x90, 0xae };
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
--- MySQL mode ---
select name
from employee
order by name asc;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | --- MySQL mode ---
select name
from employee
order by name asc; |
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use std::{sync::mpsc::Receiver, io::Write, io::stdin, io::stdout, net::IpAddr, process::exit, str, sync::Mutex, sync::mpsc, thread};
use core::convert::TryInto;
use rand::Rng;
use ring::digest;
use termion::input::TermRead;
use crate::{constants, algorithms, crypto, session::Session, kex, terminal, ed25519};
pub struct SSH{
host: IpAddr,
username: String,
client_session: Session,
ciphers: Vec<u8>,
received_ciphers: Vec<u8>,
server_host_key: Vec<u8>,
server_signature: Vec<u8>,
kex_keys: Option<kex::Kex>
}
impl SSH {
pub fn new(username: String, host: IpAddr, port: u16) -> SSH {
SSH {
host,
username,
client_session: Session::new(host, port).unwrap(),
ciphers: Vec::new(),
received_ciphers: Vec::new(),
server_host_key: Vec::new(),
server_signature: Vec::new(),
kex_keys: None,
}
}
fn get_password(&self) -> String {
let stdout = stdout();
let mut stdout = stdout.lock();
let stdin = stdin();
let mut stdin = stdin.lock();
stdout.write_all(b"password: ").unwrap();
stdout.flush().unwrap();
let password = stdin.read_passwd(&mut stdout).unwrap().unwrap();
stdout.write_all(b"\n").unwrap();
password
}
fn protocol_string_exchange(&mut self, client_protocol_string: &str) -> String{
let mut protocol_string = client_protocol_string.to_string();
protocol_string.push_str("\r\n");
self.client_session.write_line(&protocol_string).unwrap();
self.client_session.read_line().unwrap()
}
fn algorithm_exchange(&mut self, received_ciphers: Vec<u8>) {
//let _cookie = &received_ciphers[6..22];
let mut server_algorithms: Vec<&str> = Vec::new();
let mut i = 22;
for _ in 0..8 {
let mut size_bytes: [u8; 4] = [0; 4];
size_bytes.copy_from_slice(&received_ciphers[i
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | use std::{sync::mpsc::Receiver, io::Write, io::stdin, io::stdout, net::IpAddr, process::exit, str, sync::Mutex, sync::mpsc, thread};
use core::convert::TryInto;
use rand::Rng;
use ring::digest;
use termion::input::TermRead;
use crate::{constants, algorithms, crypto, session::Session, kex, terminal, ed25519};
pub struct SSH{
host: IpAddr,
username: String,
client_session: Session,
ciphers: Vec<u8>,
received_ciphers: Vec<u8>,
server_host_key: Vec<u8>,
server_signature: Vec<u8>,
kex_keys: Option<kex::Kex>
}
impl SSH {
pub fn new(username: String, host: IpAddr, port: u16) -> SSH {
SSH {
host,
username,
client_session: Session::new(host, port).unwrap(),
ciphers: Vec::new(),
received_ciphers: Vec::new(),
server_host_key: Vec::new(),
server_signature: Vec::new(),
kex_keys: None,
}
}
fn get_password(&self) -> String {
let stdout = stdout();
let mut stdout = stdout.lock();
let stdin = stdin();
let mut stdin = stdin.lock();
stdout.write_all(b"password: ").unwrap();
stdout.flush().unwrap();
let password = stdin.read_passwd(&mut stdout).unwrap().unwrap();
stdout.write_all(b"\n").unwrap();
password
}
fn protocol_string_exchange(&mut self, client_protocol_string: &str) -> String{
let mut protocol_string = client_protocol_string.to_string();
protocol_string.push_str("\r\n");
self.client_session.write_line(&protocol_string).unwrap();
self.client_session.read_line().unwrap()
}
fn algorithm_exchange(&mut self, received_ciphers: Vec<u8>) {
//let _cookie = &received_ciphers[6..22];
let mut server_algorithms: Vec<&str> = Vec::new();
let mut i = 22;
for _ in 0..8 {
let mut size_bytes: [u8; 4] = [0; 4];
size_bytes.copy_from_slice(&received_ciphers[i..i+4]);
let algo_size = u32::from_be_bytes(size_bytes);
server_algorithms.push(str::from_utf8(&received_ciphers[i+4..i+4+algo_size as usize]).unwrap());
i = i + 4 + algo_size as usize;
}
println!("[+] Server offers: {:?}", server_algorithms);
let mut ciphers: Vec<u8> = Vec::new();
let cookie: [u8; 16] = self.client_session.csprng.gen();
ciphers.push(constants::Message::SSH_MSG_KEXINIT);
ciphers.append(&mut cookie.to_vec());
println!("[+] Client offers: {:?}", algorithms::ALGORITHMS.to_vec());
for algorithm in algorithms::ALGORITHMS.to_vec() {
ciphers.append(&mut (algorithm.len() as u32).to_be_bytes().to_vec());
ciphers.append(&mut (algorithm.as_bytes().to_vec()));
}
ciphers.append(&mut vec![0;13]); // Last bytes - 0000 0000 0000 0
self.client_session.pad_data(&mut ciphers);
self.client_session.write_to_server(&ciphers).unwrap();
self.ciphers = ciphers;
self.received_ciphers = received_ciphers;
}
fn send_public_key(&mut self) {
self.kex_keys = Some(kex::Kex::new(&mut self.client_session));
let mut client_public_key = self.kex_keys.as_ref().unwrap().public_key.as_bytes().to_vec();
let mut key_exchange: Vec<u8> = Vec::new();
key_exchange.push(constants::Message::SSH_MSG_KEX_ECDH_INIT);
key_exchange.append(&mut (client_public_key.len() as u32).to_be_bytes().to_vec());
key_exchange.append(&mut client_public_key);
self.client_session.pad_data(&mut key_exchange);
self.client_session.write_to_server(&key_exchange).unwrap();
}
fn key_exchange(&mut self, received_ecdh: Vec<u8>) -> (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>) {
let mut e = Vec::new();
let pub_key = self.kex_keys.as_ref().unwrap().public_key.as_bytes();
e.append(&mut (pub_key.len() as u32).to_be_bytes().to_vec());
e.append(&mut pub_key.to_vec());
let (key_size_slice, received_ecdh) = received_ecdh.split_at(4);
let (key_algorithm_size_slice, received_ecdh) = received_ecdh.split_at(4);
let key_algorithm_size = u32::from_be_bytes(key_algorithm_size_slice.try_into().unwrap());
let (key_name, received_ecdh) = received_ecdh.split_at(key_algorithm_size as usize);
//println!("[+] Host Key Algorithm: {}", str::from_utf8(key_name).unwrap());
let (host_key_size_slice, received_ecdh) = received_ecdh.split_at(4);
let host_key_size = u32::from_be_bytes(host_key_size_slice.try_into().unwrap());
let (host_key, received_ecdh) = received_ecdh.split_at(host_key_size as usize);
self.server_host_key = host_key.to_vec();
if ed25519::host_key_fingerprint_check(
self.host,
&[key_algorithm_size_slice, key_name, host_key_size_slice, host_key].concat()
) == false {
exit(1);
}
let k_s = [
key_size_slice,
key_algorithm_size_slice,
key_name,
host_key_size_slice,
host_key]
.concat();
let (f_size_slice, received_ecdh) = received_ecdh.split_at(4);
let f_size = u32::from_be_bytes(f_size_slice.try_into().unwrap());
let (f, received_ecdh) = received_ecdh.split_at(f_size as usize);
let f: [u8;32] = f.try_into().unwrap();
let (signature_length, received_ecdh) = received_ecdh.split_at(4);
let signature_length = u32::from_be_bytes(signature_length.try_into().unwrap());
let (signature_data, _) = received_ecdh.split_at(signature_length as usize);
let (signature_algo_size, signature_data) = signature_data.split_at(4);
let signature_algo_size = u32::from_be_bytes(signature_algo_size.try_into().unwrap());
let (_, signature_data) = signature_data.split_at(signature_algo_size as usize);
//println!("[+] Signature Algorithm: {}", str::from_utf8(signature_algorithm).unwrap());
let (signature_size, signature_data) = signature_data.split_at(4);
let signature_size = u32::from_be_bytes(signature_size.try_into().unwrap());
let (signature, _) = signature_data.split_at(signature_size as usize);
self.server_signature = signature.to_vec();
let secret = self.kex_keys.as_ref().unwrap().generate_shared_secret(f);
let f = [f_size_slice, f.as_ref()].concat();
(k_s, e.to_vec(), f, self.client_session.mpint(secret.as_bytes()))
}
fn new_keys_message(&mut self){
let mut new_keys: Vec<u8> = Vec::new();
new_keys.push(constants::Message::SSH_MSG_NEWKEYS);
self.client_session.pad_data(&mut new_keys);
self.client_session.write_to_server(&new_keys).unwrap();
self.client_session.encrypted = true;
}
fn service_request_message(&mut self){
let mut service_request: Vec<u8> = Vec::new();
service_request.push(constants::Message::SSH_MSG_SERVICE_REQUEST);
service_request.append(&mut (constants::Strings::SSH_USERAUTH.len() as u32).to_be_bytes().to_vec());
service_request.append(&mut constants::Strings::SSH_USERAUTH.as_bytes().to_vec());
self.client_session.pad_data(&mut service_request);
self.client_session.encrypt_packet(&mut service_request);
self.client_session.write_to_server(&mut service_request).unwrap();
}
fn password_authentication(&mut self, username: String, password: String){
let mut password_auth: Vec<u8> = Vec::new();
password_auth.push(constants::Message::SSH_MSG_USERAUTH_REQUEST);
password_auth.append(&mut (username.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut username.as_bytes().to_vec());
password_auth.append(&mut (constants::Strings::SSH_CONNECTION.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut constants::Strings::SSH_CONNECTION.as_bytes().to_vec());
password_auth.append(&mut (constants::Strings::PASSWORD.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut constants::Strings::PASSWORD.as_bytes().to_vec());
password_auth.push(0);
password_auth.append(&mut (password.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut password.as_bytes().to_vec());
self.client_session.pad_data(&mut password_auth);
self.client_session.encrypt_packet(&mut password_auth);
self.client_session.write_to_server(&mut password_auth).unwrap();
}
fn open_channel(&mut self) {
let mut open_request: Vec<u8> = Vec::new();
open_request.push(constants::Message::SSH_MSG_CHANNEL_OPEN);
open_request.append(&mut (constants::Strings::SESSION.len() as u32).to_be_bytes().to_vec());
open_request.append(&mut constants::Strings::SESSION.as_bytes().to_vec());
open_request.append(&mut (1 as u32).to_be_bytes().to_vec());
open_request.append(&mut (self.client_session.client_window_size as u32).to_be_bytes().to_vec());
open_request.append(&mut constants::Size::MAX_PACKET_SIZE.to_be_bytes().to_vec());
self.client_session.pad_data(&mut open_request);
self.client_session.encrypt_packet(&mut open_request);
self.client_session.write_to_server(&mut open_request).unwrap();
}
fn channel_request_pty(&mut self){
let terminal_size = terminal::get_terminal_size().unwrap();
let mut channel_request: Vec<u8> = Vec::new();
channel_request.push(constants::Message::SSH_MSG_CHANNEL_REQUEST);
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (constants::Strings::PTY_REQ.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::PTY_REQ.as_bytes().to_vec());
channel_request.push(0);
channel_request.append(&mut (constants::Strings::XTERM_VAR.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::XTERM_VAR.as_bytes().to_vec());
channel_request.append(&mut (terminal_size.0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (terminal_size.1 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (11 as u32).to_be_bytes().to_vec());
channel_request.push(0x81);
channel_request.append(&mut (38400 as u32).to_be_bytes().to_vec());
channel_request.push(0x80);
channel_request.append(&mut (38400 as u32).to_be_bytes().to_vec());
channel_request.push(0);
self.client_session.pad_data(&mut channel_request);
self.client_session.encrypt_packet(&mut channel_request);
self.client_session.write_to_server(&mut channel_request).unwrap();
}
fn channel_request_shell(&mut self) {
let mut channel_request: Vec<u8> = Vec::new();
channel_request.push(constants::Message::SSH_MSG_CHANNEL_REQUEST);
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (constants::Strings::SHELL.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::SHELL.as_bytes().to_vec());
channel_request.push(1);
self.client_session.pad_data(&mut channel_request);
self.client_session.encrypt_packet(&mut channel_request);
self.client_session.write_to_server(&mut channel_request).unwrap();
}
fn window_adjust(&mut self) {
let mut window_adjust: Vec<u8> = Vec::new();
window_adjust.push(constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST);
window_adjust.append(&mut (0 as u32).to_be_bytes().to_vec());
window_adjust.append(&mut self.client_session.client_window_size.to_be_bytes().to_vec());
self.client_session.pad_data(&mut window_adjust);
self.client_session.encrypt_packet(&mut window_adjust);
self.client_session.write_to_server(&mut window_adjust).unwrap();
}
fn handle_key(&mut self, mut key: Vec<u8>) {
let mut command: Vec<u8> = Vec::new();
command.push(constants::Message::SSH_MSG_CHANNEL_DATA);
command.append(&mut (0 as u32).to_be_bytes().to_vec());
command.append(&mut (key.len() as u32).to_be_bytes().to_vec());
command.append(&mut key);
self.client_session.pad_data(&mut command);
self.client_session.encrypt_packet(&mut command);
self.client_session.write_to_server(&mut command).unwrap();
}
fn get_key(&mut self, rx: &Receiver<Vec<u8>>) {
let result = rx.try_recv();
match result {
Ok(vec) => self.handle_key(vec),
Err(_) => (),
}
}
fn close_channel(&mut self) {
let mut close: Vec<u8> = Vec::new();
close.push(constants::Message::SSH_MSG_CHANNEL_CLOSE);
close.append(&mut (0 as u32).to_be_bytes().to_vec());
self.client_session.pad_data(&mut close);
self.client_session.encrypt_packet(&mut close);
self.client_session.write_to_server(&mut close).unwrap();
}
pub fn ssh_protocol(&mut self) -> std::io::Result<()>{
let (tx, rx) = mpsc::channel();
let mut terminal_launched = false;
// Protocol String Exchange
let server_protocol_string = self.protocol_string_exchange(constants::Strings::CLIENT_VERSION);
println!("[+] Server version: {}", server_protocol_string.trim());
// Main loop
loop {
// If no data is read then queue is empty
let queue = self.client_session.read_from_server();
// Adjust window
if self.client_session.data_received >= self.client_session.client_window_size {
self.client_session.data_received = 0;
self.window_adjust();
}
// Process key strokes
self.get_key(&rx);
for packet in queue {
// To give a chance to process special input
// while processing packets
self.get_key(&rx);
let (_, data_no_size) = packet.split_at(4);
let (_padding, data_no_size) = data_no_size.split_at(1);
let (code, data_no_size) = data_no_size.split_at(1);
// Process each packet by matching the message code
match code[0] {
constants::Message::SSH_MSG_KEXINIT => {
//println!("[+] Received Code {}", constants::Message::SSH_MSG_KEXINIT);
// Algorithm exchange
// TODO - Check if client and server algorithms match
self.algorithm_exchange(packet);
self.send_public_key();
}
constants::Message::SSH_MSG_KEX_ECDH_REPLY => {
let (mut k_s, mut e, mut f, mut k) = self.key_exchange(data_no_size.to_vec());
// Make Session ID
// TODO - Change this when implementing rekey
// Note: Rekey should be triggered every 1GB or every hour
self.client_session.make_session_id(
&digest::SHA256,
server_protocol_string.clone(),
&mut self.ciphers,
&mut self.received_ciphers,
&mut k_s,
&mut e,
&mut f,
&mut k.clone());
let verification = ed25519::verify_server_signature(
&self.server_signature,
&self.server_host_key,
&self.client_session.session_id);
if verification == false { println!("Server's signature does not match!"); exit(1); }
let mut session_id = self.client_session.session_id.clone();
let keys = crypto::Keys::new(
&digest::SHA256,
&mut k,
&mut self.client_session.session_id,
&mut session_id);
let session_keys = crypto::SessionKeys::new(keys);
self.client_session.session_keys = Some(session_keys);
self.new_keys_message();
// Request authentication
self.service_request_message();
}
constants::Message::SSH_MSG_SERVICE_ACCEPT => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_SERVICE_ACCEPT);
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//println!("{}", str::from_utf8(&data_no_size[..size as usize]).unwrap());
// Password authentication
// TODO - Implement other types of authentication (keys)
let password = <PASSWORD>();
self.password_authentication(self.username.clone(), password);
}
constants::Message::SSH_MSG_USERAUTH_FAILURE => {
println!("[+] Authentication failed!");
println!("Try again.");
let password = <PASSWORD>();
self.password_authentication(self.username.clone(), password);
}
constants::Message::SSH_MSG_USERAUTH_SUCCESS => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_USERAUTH_SUCCESS);
println!("[+] Authentication succeeded.");
self.open_channel();
}
constants::Message::SSH_MSG_GLOBAL_REQUEST => {
// TODO - Handle host key check upon receiving -> <EMAIL>
// Ignore for now
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_GLOBAL_REQUEST);
}
constants::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//let (recipient_channel, data_no_size) = data_no_size.split_at(4);
//let (sender_channel, data_no_size) = data_no_size.split_at(4);
//let (initial_window_size, data_no_size) = data_no_size.split_at(4);
//let (maximum_window_size, data_no_size) = data_no_size.split_at(4);
// Request pseudo terminal / shell
self.channel_request_pty();
self.channel_request_shell();
terminal_launched = true;
}
constants::Message::SSH_MSG_CHANNEL_OPEN_FAILURE => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_OPEN_FAILURE);
println!("[+] Channel open failed, exiting.");
exit(1);
}
constants::Message::SSH_MSG_CHANNEL_SUCCESS => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_SUCCESS);
println!("[+] Channel open succeeded.");
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//let (recipient_channel, data_no_size) = data_no_size.split_at(4);
}
constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST);
let (_recipient_channel, data_no_size) = data_no_size.split_at(4);
let (window_bytes, _) = data_no_size.split_at(4);
let mut window_slice = [0u8;4];
window_slice.copy_from_slice(window_bytes);
self.client_session.server_window_size = u32::from_be_bytes(window_slice);
}
constants::Message::SSH_MSG_CHANNEL_DATA => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_DATA);
let (_recipient_channel, data_no_size) = data_no_size.split_at(4);
let (data_size, data_no_size) = data_no_size.split_at(4);
let data_size = u32::from_be_bytes(data_size.try_into().unwrap());
// Launch thread that processes key strokes
if terminal_launched == true {
let clone = tx.clone();
thread::spawn(move ||{
let mut terminal = terminal::Terminal::new(Mutex::new(clone));
terminal.handle_command();
});
terminal_launched = false;
}
// Print data received to screen
stdout().write_all(&data_no_size[..data_size as usize]).unwrap();
stdout().flush().unwrap();
}
constants::Message::SSH_MSG_CHANNEL_EOF => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_EOF);
println!("Server will not send more data!");
}
constants::Message::SSH_MSG_CHANNEL_REQUEST => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_REQUEST);
}
constants::Message::SSH_MSG_IGNORE => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_IGNORE);
}
constants::Message::SSH_MSG_CHANNEL_CLOSE => {
// Issue close channel packet
self.close_channel();
println!("Connection closed.");
exit(0);
}
constants::Message::SSH_MSG_DISCONNECT => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_DISCONNECT);
println!("Server disconnected...");
exit(1);
}
_ => {
println!("Could not recognize this message -> {}", code[0]);
exit(1);
}
}
}
}
}
} |
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# T312_Sarangga
Second repository
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 1 | # T312_Sarangga
Second repository
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<section class="pcoded-main-container">
<div class="pcoded-wrapper">
<div class="pcoded-content">
<div class="pcoded-inner-content">
<div class="page-header">
<div class="page-block">
<div class="row align-items-center">
<div class="col-md-12">
<div class="page-header-title">
<h5 class="m-b-10">Bank Soal</h5>
</div>
<ul class="breadcrumb">
<li class="breadcrumb-item"><a href="#">
<i class="feather icon-user"></i></a></li>
<li class="breadcrumb-item"><a href="javascript:">Bank Soal</a></li>
<li class="breadcrumb-item"><a href="javascript:">Data</a></li>
</ul>
</div>
</div>
</div>
</div>
<div class="main-body">
<div class="page-wrapper">
<div class="row">
<div class="col-sm-12">
<div class="card">
<div class="card-header">
<h5>Data Bank Soal IPS</h5>
</div>
<div class="card-block">
<div class="col-md-12">
<div class="row mx-auto">
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sejarah') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 1 | <section class="pcoded-main-container">
<div class="pcoded-wrapper">
<div class="pcoded-content">
<div class="pcoded-inner-content">
<div class="page-header">
<div class="page-block">
<div class="row align-items-center">
<div class="col-md-12">
<div class="page-header-title">
<h5 class="m-b-10">Bank Soal</h5>
</div>
<ul class="breadcrumb">
<li class="breadcrumb-item"><a href="#">
<i class="feather icon-user"></i></a></li>
<li class="breadcrumb-item"><a href="javascript:">Bank Soal</a></li>
<li class="breadcrumb-item"><a href="javascript:">Data</a></li>
</ul>
</div>
</div>
</div>
</div>
<div class="main-body">
<div class="page-wrapper">
<div class="row">
<div class="col-sm-12">
<div class="card">
<div class="card-header">
<h5>Data Bank Soal IPS</h5>
</div>
<div class="card-block">
<div class="col-md-12">
<div class="row mx-auto">
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sejarah') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Sejarah</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sosiologi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Sosiologi</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_geografi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Geografi</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_ekonomi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Ekonomi</h4>
</a>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</section> |
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { SectionTableRow, CoursePageData } from "src/models/pages";
import { CoursePageScraper } from "src/util/scraper";
import { search } from "../../../src/util/helpers";
describe("CoursePageScraper.ts", () => {
const coursePageScraper = new CoursePageScraper();
beforeAll(() => {
})
it("getData should return data for CPSC 221 and contain section 101 and L1A", async () => {
const cpscSection: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 101",
subject: "CPSC",
course: "221",
section: "101",
activity: "Web-Oriented Course",
term: "1",
interval: "",
schedule: [
{
day: "Mon",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Wed",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Fri",
term: "1",
start_time: "14:00",
end_time: "15:00",
}
],
comments: "If all the lab and/or tutorial seats are full the department will ensure that there are enough lab/tutorial seats available for the number of students registered in the course by either adding additional lab/tutorial sections or expenadind the number of seats in the activity once we know how many extra students we will need to accommodate. However, there is no guarantee that these seats will fit your preferred time. You may need to change your registration in other courses to get access to a lab/tutorial where there are available seats.",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=101&campuscd=UBC"
}
const cpscLab: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 L1A",
subject: "CPSC",
course: "221",
section: "L1A",
activity: "Laboratory",
term: "1",
interval: "",
schedu
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 3 | import { SectionTableRow, CoursePageData } from "src/models/pages";
import { CoursePageScraper } from "src/util/scraper";
import { search } from "../../../src/util/helpers";
describe("CoursePageScraper.ts", () => {
const coursePageScraper = new CoursePageScraper();
beforeAll(() => {
})
it("getData should return data for CPSC 221 and contain section 101 and L1A", async () => {
const cpscSection: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 101",
subject: "CPSC",
course: "221",
section: "101",
activity: "Web-Oriented Course",
term: "1",
interval: "",
schedule: [
{
day: "Mon",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Wed",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Fri",
term: "1",
start_time: "14:00",
end_time: "15:00",
}
],
comments: "If all the lab and/or tutorial seats are full the department will ensure that there are enough lab/tutorial seats available for the number of students registered in the course by either adding additional lab/tutorial sections or expenadind the number of seats in the activity once we know how many extra students we will need to accommodate. However, there is no guarantee that these seats will fit your preferred time. You may need to change your registration in other courses to get access to a lab/tutorial where there are available seats.",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=101&campuscd=UBC"
}
const cpscLab: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 L1A",
subject: "CPSC",
course: "221",
section: "L1A",
activity: "Laboratory",
term: "1",
interval: "",
schedule: [
{
day: "Tue",
term: "1",
start_time: "11:00",
end_time: "13:00",
}
],
comments: "",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=L1A&campuscd=UBC"
}
const expected: CoursePageData = {
name: "CPSC 221",
subject: "CPSC",
course: "221",
title: "Basic Algorithms and Data Structures",
description: "Design and analysis of basic algorithms and data structures; algorithm analysis methods, searching and sorting algorithms, basic data structures, graphs and concurrency.",
credits: "4",
comments: ["Choose one section from all 2 activity types. (e.g. Lecture and Laboratory)"],
sections: expect.any(Array),
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-course&dept=CPSC&course=221&campuscd=UBC"
}
let result = await coursePageScraper.getData("CPSC", "221");
let lab = search("name", "CPSC 221 L1A", result.sections);
let section = search("name", "CPSC 221 101", result.sections);
expect(result).toMatchObject(expected);
expect(lab).toMatchObject(cpscLab);
expect(section).toMatchObject(cpscSection);
expect(result.sections.length).toBeGreaterThan(20); // definately more than 20 sections... dont know the exact number
})
}) |
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
Create tables:
1) Create a table with Personentity under Test Schema.
a. PersonentityID auto increment ID,PK
b. PersonFName
c. PersonLName
d. PersonDOB
e. PersonAddress
f. InsertedDate Auto value
2) Create a table with Costumer under Test Schema.
a. CostumerID auto increment ID,PK
b. CostumerFName
c. CostumerLName
d. CostumerAccountNumber
e. InsertedDate Auto Value
3) Create a table with Player under Test Schema.
a. PlayerID
b. PlayerName
c. ManagerName
d. TeamName
e. InsertedDate Auto value
Insertion:
Build some Query from three databases and pick 100 ,200, 300 records and load them into tables.
Personentity Source from Adventureworks2017 DB
Costumer Source from AdventureworksDW2017 DB
Player BaseBall DB
Extract :
join on three table ID and get me some good information from three tables.
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | Create tables:
1) Create a table with Personentity under Test Schema.
a. PersonentityID auto increment ID,PK
b. PersonFName
c. PersonLName
d. PersonDOB
e. PersonAddress
f. InsertedDate Auto value
2) Create a table with Costumer under Test Schema.
a. CostumerID auto increment ID,PK
b. CostumerFName
c. CostumerLName
d. CostumerAccountNumber
e. InsertedDate Auto Value
3) Create a table with Player under Test Schema.
a. PlayerID
b. PlayerName
c. ManagerName
d. TeamName
e. InsertedDate Auto value
Insertion:
Build some Query from three databases and pick 100 ,200, 300 records and load them into tables.
Personentity Source from Adventureworks2017 DB
Costumer Source from AdventureworksDW2017 DB
Player BaseBall DB
Extract :
join on three table ID and get me some good information from three tables.
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-portfolio-skills',
templateUrl: './portfolio-skills.component.html',
styleUrls: ['./portfolio-skills.component.scss']
})
export class PortfolioSkillsComponent implements OnInit {
static readonly skills = [
'HTML5',
'CSS',
'JavaScript',
'Java',
'Angular',
'TypeScript',
'MySQL',
'Sass',
'Spring',
'REST'
];
constructor() { }
cards: any[] = [];
ngOnInit() {
PortfolioSkillsComponent.skills.forEach(skill => {
this.cards.push( {'image': skill.toLowerCase(), 'name': skill} );
});
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 3 | import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-portfolio-skills',
templateUrl: './portfolio-skills.component.html',
styleUrls: ['./portfolio-skills.component.scss']
})
export class PortfolioSkillsComponent implements OnInit {
static readonly skills = [
'HTML5',
'CSS',
'JavaScript',
'Java',
'Angular',
'TypeScript',
'MySQL',
'Sass',
'Spring',
'REST'
];
constructor() { }
cards: any[] = [];
ngOnInit() {
PortfolioSkillsComponent.skills.forEach(skill => {
this.cards.push( {'image': skill.toLowerCase(), 'name': skill} );
});
}
}
|
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# Quiz
first android project
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 1 | # Quiz
first android project
|
Below is an extract from a C++ program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C++ code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C++ concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., memory management). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C++. It should be similar to a school exercise, a tutorial, or a C++ course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C++. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/utils/SkTextUtils.h"
#include <initializer_list>
class SkCanvas;
// http://bug.skia.org/7315
DEF_SIMPLE_GM(text_scale_skew, canvas, 256, 128) {
SkPaint p;
p.setAntiAlias(true);
SkFont font;
font.setSize(18.0f);
float y = 10.0f;
for (float scale : { 0.5f, 0.71f, 1.0f, 1.41f, 2.0f }) {
font.setScaleX(scale);
y += font.getSpacing();
float x = 50.0f;
for (float skew : { -0.5f, 0.0f, 0.5f }) {
font.setSkewX(skew);
SkTextUtils::DrawString(canvas, "Skia", x, y, font, p, SkTextUtils::kCenter_Align);
x += 78.0f;
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| cpp | 3 | /*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/utils/SkTextUtils.h"
#include <initializer_list>
class SkCanvas;
// http://bug.skia.org/7315
DEF_SIMPLE_GM(text_scale_skew, canvas, 256, 128) {
SkPaint p;
p.setAntiAlias(true);
SkFont font;
font.setSize(18.0f);
float y = 10.0f;
for (float scale : { 0.5f, 0.71f, 1.0f, 1.41f, 2.0f }) {
font.setScaleX(scale);
y += font.getSpacing();
float x = 50.0f;
for (float skew : { -0.5f, 0.0f, 0.5f }) {
font.setSkewX(skew);
SkTextUtils::DrawString(canvas, "Skia", x, y, font, p, SkTextUtils::kCenter_Align);
x += 78.0f;
}
}
}
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (status, nextRetry);
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (relatedPHID);
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (status, nextRetry);
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (relatedPHID);
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/**
* Created by china on 2018/3/16.
*/
/*
当前项目接口ajax请求模块
*/
import ajax from './ajax'
export const reqhome = () => ajax('/home')
export const reqleft = () => ajax('/type/left')
export const reqright = () => ajax('/type/right')
export const reqbrand = () => ajax('/brand')
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | /**
* Created by china on 2018/3/16.
*/
/*
当前项目接口ajax请求模块
*/
import ajax from './ajax'
export const reqhome = () => ajax('/home')
export const reqleft = () => ajax('/type/left')
export const reqright = () => ajax('/type/right')
export const reqbrand = () => ajax('/brand')
|
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//Copyright 2017 Huawei Technologies Co., Ltd
//
//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 lagertest
import (
"bytes"
"encoding/json"
"io"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega/gbytes"
"github.com/ServiceComb/service-center/pkg/lager"
)
type TestLogger struct {
lager.Logger
*TestSink
}
type TestSink struct {
lager.Sink
buffer *gbytes.Buffer
}
func NewTestLogger(component string) *TestLogger {
logger := lager.NewLogger(component)
testSink := NewTestSink()
logger.RegisterSink(testSink)
logger.RegisterSink(lager.NewWriterSink(ginkgo.GinkgoWriter, lager.DEBUG))
return &TestLogger{logger, testSink}
}
func NewTestSink() *TestSink {
buffer := gbytes.NewBuffer()
return &TestSink{
Sink: lager.NewWriterSink(buffer, lager.DEBUG),
buffer: buffer,
}
}
func (s *TestSink) Buffer() *gbytes.Buffer {
return s.buffer
}
func (s *TestSink) Logs() []lager.LogFormat {
logs := []lager.LogFormat{}
decoder := json.NewDecoder(bytes.NewBuffer(s.buffer.Contents()))
for {
var log lager.LogFormat
if err := decoder.Decode(&log); err == io.EOF {
return logs
} else if err != nil {
panic(err)
}
logs = append(logs, log)
}
return logs
}
func (s *TestSink) LogMessages() []string {
logs := s.Logs()
messages := make([]string, 0, len(logs))
for _, log := range logs {
messages = append(messages, log.Message)
}
return messages
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 1 | //Copyright 2017 Huawei Technologies Co., Ltd
//
//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 lagertest
import (
"bytes"
"encoding/json"
"io"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega/gbytes"
"github.com/ServiceComb/service-center/pkg/lager"
)
type TestLogger struct {
lager.Logger
*TestSink
}
type TestSink struct {
lager.Sink
buffer *gbytes.Buffer
}
func NewTestLogger(component string) *TestLogger {
logger := lager.NewLogger(component)
testSink := NewTestSink()
logger.RegisterSink(testSink)
logger.RegisterSink(lager.NewWriterSink(ginkgo.GinkgoWriter, lager.DEBUG))
return &TestLogger{logger, testSink}
}
func NewTestSink() *TestSink {
buffer := gbytes.NewBuffer()
return &TestSink{
Sink: lager.NewWriterSink(buffer, lager.DEBUG),
buffer: buffer,
}
}
func (s *TestSink) Buffer() *gbytes.Buffer {
return s.buffer
}
func (s *TestSink) Logs() []lager.LogFormat {
logs := []lager.LogFormat{}
decoder := json.NewDecoder(bytes.NewBuffer(s.buffer.Contents()))
for {
var log lager.LogFormat
if err := decoder.Decode(&log); err == io.EOF {
return logs
} else if err != nil {
panic(err)
}
logs = append(logs, log)
}
return logs
}
func (s *TestSink) LogMessages() []string {
logs := s.Logs()
messages := make([]string, 0, len(logs))
for _, log := range logs {
messages = append(messages, log.Message)
}
return messages
}
|
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package datatype_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/i-sevostyanov/NanoDB/internal/sql"
"github.com/i-sevostyanov/NanoDB/internal/sql/datatype"
)
func TestNull_Raw(t *testing.T) {
t.Parallel()
null := datatype.NewNull()
switch value := null.Raw().(type) {
case nil:
default:
assert.Failf(t, "fail", "unexpected type %T", value)
}
}
func TestNull_DataType(t *testing.T) {
t.Parallel()
n := datatype.NewNull()
assert.Equal(t, sql.Null, n.DataType())
}
func TestNull_Compare(t *testing.T) {
t.Parallel()
tests := []struct {
name string
a sql.Value
b sql.Value
cmp sql.CompareType
}{
{
name: "null vs null",
a: datatype.NewNull(),
b: datatype.NewNull(),
cmp: sql.Equal,
},
{
name: "null vs integer",
a: datatype.NewNull(),
b: datatype.NewInteger(10),
cmp: sql.Less,
},
{
name: "null vs float",
a: datatype.NewNull(),
b: datatype.NewFloat(10),
cmp: sql.Less,
},
{
name: "null vs text",
a: datatype.NewNull(),
b: datatype.NewText("xyz"),
cmp: sql.Less,
},
{
name: "null vs boolean",
a: datatype.NewNull(),
b: datatype.NewBoolean(true),
cmp: sql.Less,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
cmp, err := test.a.Compare(test.b)
require.NoError(t, err)
assert.Equal(t, test.cmp, cmp)
})
}
}
func TestNull_UnaryPlus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryPlus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_UnaryMinus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryMinus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_Add(t *testing.T) {
t.Parallel()
t.Run("null + null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Add(b)
require
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 3 | package datatype_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/i-sevostyanov/NanoDB/internal/sql"
"github.com/i-sevostyanov/NanoDB/internal/sql/datatype"
)
func TestNull_Raw(t *testing.T) {
t.Parallel()
null := datatype.NewNull()
switch value := null.Raw().(type) {
case nil:
default:
assert.Failf(t, "fail", "unexpected type %T", value)
}
}
func TestNull_DataType(t *testing.T) {
t.Parallel()
n := datatype.NewNull()
assert.Equal(t, sql.Null, n.DataType())
}
func TestNull_Compare(t *testing.T) {
t.Parallel()
tests := []struct {
name string
a sql.Value
b sql.Value
cmp sql.CompareType
}{
{
name: "null vs null",
a: datatype.NewNull(),
b: datatype.NewNull(),
cmp: sql.Equal,
},
{
name: "null vs integer",
a: datatype.NewNull(),
b: datatype.NewInteger(10),
cmp: sql.Less,
},
{
name: "null vs float",
a: datatype.NewNull(),
b: datatype.NewFloat(10),
cmp: sql.Less,
},
{
name: "null vs text",
a: datatype.NewNull(),
b: datatype.NewText("xyz"),
cmp: sql.Less,
},
{
name: "null vs boolean",
a: datatype.NewNull(),
b: datatype.NewBoolean(true),
cmp: sql.Less,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
cmp, err := test.a.Compare(test.b)
require.NoError(t, err)
assert.Equal(t, test.cmp, cmp)
})
}
}
func TestNull_UnaryPlus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryPlus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_UnaryMinus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryMinus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_Add(t *testing.T) {
t.Parallel()
t.Run("null + null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Add(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null + integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null + float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null + text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Sub(t *testing.T) {
t.Parallel()
t.Run("null - null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Sub(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null - integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null - float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null - text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Mul(t *testing.T) {
t.Parallel()
t.Run("null * null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Mul(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null * integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null * float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null * text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Div(t *testing.T) {
t.Parallel()
t.Run("null / null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Div(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null / integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null / float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null / text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Pow(t *testing.T) {
t.Parallel()
t.Run("null ^ null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Pow(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null ^ integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null ^ float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null ^ text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Mod(t *testing.T) {
t.Parallel()
t.Run("null % null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Mod(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null % integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null % float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null % text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Equal(t *testing.T) {
t.Parallel()
t.Run("null == null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Equal(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null == integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null == float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null == text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_NotEqual(t *testing.T) {
t.Parallel()
t.Run("null != null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.NotEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null != integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null != float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null != text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_GreaterThan(t *testing.T) {
t.Parallel()
t.Run("null > null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.GreaterThan(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null > integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null > float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null > text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_LessThan(t *testing.T) {
t.Parallel()
t.Run("null < null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.LessThan(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null < integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null < float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null < text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_GreaterOrEqual(t *testing.T) {
t.Parallel()
t.Run("null >= null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.GreaterOrEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null >= integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null >= float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null >= text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_LessOrEqual(t *testing.T) {
t.Parallel()
t.Run("null <= null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.LessOrEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null <= integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null <= float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null <= text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_And(t *testing.T) {
t.Parallel()
t.Run("null AND null -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null AND true -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(true)
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null AND false -> false", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(false)
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewBoolean(false), value)
})
t.Run("null AND integer -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null AND float -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null AND text -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
}
func TestNull_Or(t *testing.T) {
t.Parallel()
t.Run("null OR null -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null OR true -> true", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(true)
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewBoolean(true), value)
})
t.Run("null OR false -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(false)
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null OR integer -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null OR float -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null OR text -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
}
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
// RW2STL - inserted:
#include <string>
#include <ostream>
#include <scenario/src/RWToSTLHelpers.h>
// End of RW2STL - inserted includes.
// file: mPlantH.C
// author: tom
#include <stdlib.h>
#include <assert.h>
#include <mcl/src/mcl.h>
#include <scenario/src/machdep.h>
#include <sce/src/sceDefin.h>
#include <sce/src/mPlantH.h>
#include <wit/src/wit.h>
#include <sce/src/appData.h>
#include <sce/src/dmApData.h>
#if 1
// #ifdef VARIABLE_PERIODS
#include <scenario/src/calendar.h>
#endif
#define MULTIPLANTHELPER_FLT_EPS 0.00001
#ifndef ELIMINATE_OLD_MAIN
// plannerPartName/Geo ---> mfgPart/Pdf source
// feed it a part (without a PDF prepended) and a geo.c_str() (ie, a demand name)
// and it returns a PDF_Part
// You also feed it a start period, and it figures the latest period for
// which this pdf is sourced for this demand
std::string
LgFrMultiPlantHelper::demandSource(
WitRun * const theWitRun,
const std::string & plannerPartName,
const std::string & geo,
const int start,
int & late,
float & offset,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
{
std::string mfgTopLevelBuild;
int bomStart = 0;
int bomEnd = 0;
// create a geoPlannerPart name
std::string geoPlannerDemandPartName = this->geoPlannerDemandPartName(plannerPartName, geo);
// and test to see if it exists (it should)
int result = this->isPartValid(theWitRun, geoPlannerDemandPartName, fileName,
dataLine, lineNo, messageLogic);
if (! result)
return mfgTopLevelBuild;
// loop through the BOM entries for this special demand part and find
// the bom which has effectivity within the period "start". Return the
// pdf of this mfgTopLevelBuild
// We also return the time-offset for this demand source
int nBom;
witGetOperationNBomEntries(theWitRun, geoPlannerDemandPartName.c_str(), &nBom);
char * chi
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 1 |
// RW2STL - inserted:
#include <string>
#include <ostream>
#include <scenario/src/RWToSTLHelpers.h>
// End of RW2STL - inserted includes.
// file: mPlantH.C
// author: tom
#include <stdlib.h>
#include <assert.h>
#include <mcl/src/mcl.h>
#include <scenario/src/machdep.h>
#include <sce/src/sceDefin.h>
#include <sce/src/mPlantH.h>
#include <wit/src/wit.h>
#include <sce/src/appData.h>
#include <sce/src/dmApData.h>
#if 1
// #ifdef VARIABLE_PERIODS
#include <scenario/src/calendar.h>
#endif
#define MULTIPLANTHELPER_FLT_EPS 0.00001
#ifndef ELIMINATE_OLD_MAIN
// plannerPartName/Geo ---> mfgPart/Pdf source
// feed it a part (without a PDF prepended) and a geo.c_str() (ie, a demand name)
// and it returns a PDF_Part
// You also feed it a start period, and it figures the latest period for
// which this pdf is sourced for this demand
std::string
LgFrMultiPlantHelper::demandSource(
WitRun * const theWitRun,
const std::string & plannerPartName,
const std::string & geo,
const int start,
int & late,
float & offset,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
{
std::string mfgTopLevelBuild;
int bomStart = 0;
int bomEnd = 0;
// create a geoPlannerPart name
std::string geoPlannerDemandPartName = this->geoPlannerDemandPartName(plannerPartName, geo);
// and test to see if it exists (it should)
int result = this->isPartValid(theWitRun, geoPlannerDemandPartName, fileName,
dataLine, lineNo, messageLogic);
if (! result)
return mfgTopLevelBuild;
// loop through the BOM entries for this special demand part and find
// the bom which has effectivity within the period "start". Return the
// pdf of this mfgTopLevelBuild
// We also return the time-offset for this demand source
int nBom;
witGetOperationNBomEntries(theWitRun, geoPlannerDemandPartName.c_str(), &nBom);
char * child;
int j = 0; // Pulled out of the for below by RW2STL
for (j=0; j<nBom; j++) {
// if the child is not a normal part, then we can skip it. (GPD's only
// source to normal parts)
// first check to see if the child is a specialDemand UpperBound part, OR
// a specialBb category part, if so, then skip it.
witGetBomEntryConsumedPart(theWitRun, geoPlannerDemandPartName.c_str(), j, &child);
std::string pp;
std::string g;
std::string bb;
if (! this->isPartNormal(theWitRun, child)) {
witFree(child);
continue;
}
witGetBomEntryEarliestPeriod(theWitRun, geoPlannerDemandPartName.c_str(), j, &bomStart);
witGetBomEntryLatestPeriod(theWitRun, geoPlannerDemandPartName.c_str(), j, &bomEnd);
if (start >= bomStart && start <= bomEnd) {
mfgTopLevelBuild = child;
witGetBomEntryUsageTime(theWitRun, geoPlannerDemandPartName.c_str(), j, &offset);
}
witFree(child);
if (! mfgTopLevelBuild.empty())
break;
}
// What to do if you can't source it?????
if (mfgTopLevelBuild.empty()) {
(*sceErrFacility_)("MissingPDFSource",MclArgList() << plannerPartName << geo << start
<< fileName << (int)lineNo << dataLine);
}
// set late as the bomEnd
late = bomEnd;
return mfgTopLevelBuild;
}
// =============================
// =============================
// SCE 6.1
// =============================
// =============================
// VARIABLE_PERIODS ...should erase all others ...note that the transit time offset returned is already adjusted for variable periods
// plannerPartName/Geo ---> mfgPart/Pdf source
// THIS IS A BETTER ONE. !!!!!!
// feed it a part (without a PDF prepended) and a geo.c_str() (ie, a demand name)
// and it returns a PDF_Part
// You also feed it a start period, and it figures the latest period for
// which this pdf is sourced for this demand
std::string
LgFrMultiPlantHelper::demandSource(
WitRun * const theWitRun,
const std::string & plannerPartName,
const std::string & geo,
const int start,
int & late,
LgFrTimeVecFloat & offsetTV,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
{
std::string mfgTopLevelBuild;
int bomStart = 0;
int bomEnd = 0;
// create a geoPlannerPart name
std::string geoPlannerDemandPartName = this->geoPlannerDemandPartName(plannerPartName, geo);
// and test to see if it exists (it should)
int result = this->isPartValid(theWitRun, geoPlannerDemandPartName, fileName, dataLine, lineNo, messageLogic);
if (! result)
return mfgTopLevelBuild;
// loop through the BOM entries for this special demand part and find
// the bom which has effectivity within the period "start". Return the
// pdf of this mfgTopLevelBuild
// We also return the time-offset for this demand source
int nBom;
witGetOperationNBomEntries(theWitRun, geoPlannerDemandPartName.c_str(), &nBom);
char * child;
int j = 0;
for (j=0; j<nBom; j++) {
// if the child is not a normal part, then we can skip it. (GPD's only
// source to normal parts)
// first check to see if the child is a specialDemand UpperBound part, OR
// a specialBb category part, if so, then skip it.
witGetBomEntryConsumedPart(theWitRun, geoPlannerDemandPartName.c_str(), j, &child);
std::string pp;
std::string g;
std::string bb;
if (! this->isPartNormal(theWitRun, child)) {
witFree(child);
continue;
}
witGetBomEntryEarliestPeriod(theWitRun, geoPlannerDemandPartName.c_str(), j, &bomStart);
witGetBomEntryLatestPeriod(theWitRun, geoPlannerDemandPartName.c_str(), j, &bomEnd);
if (start >= bomStart && start <= bomEnd) {
mfgTopLevelBuild = child;
float * offset;
int ttt=0;
witGetBomEntryOffset(theWitRun, geoPlannerDemandPartName.c_str(), j, &offset);
for (ttt=start; ttt<=late; ttt++)
offsetTV[ttt] = offset[ttt];
witFree(offset);
}
witFree(child);
if (! mfgTopLevelBuild.empty())
break;
}
// What to do if you can't source it?????
if (mfgTopLevelBuild.empty()) {
(*sceErrFacility_)("MissingPDFSource",MclArgList() << plannerPartName << geo << start << fileName << (int)lineNo << dataLine);
}
// set late as the bomEnd
late = bomEnd;
return mfgTopLevelBuild;
}
// feed it a GPD planner part and geo (with D2o), and it returns the topMfgPart of the machine, and
// populates the sourceLocPdf reference
std::string
LgFrMultiPlantHelper::mfgTopPartForGpd(WitRun * const theWitRun,
const std::string & plannerPartName,
const std::string & d2oGeo,
std::string & sourceLocPdf)
{
sourceLocPdf = this->sourceLoc(d2oGeo);
return this->pdfPartname(plannerPartName, sourceLocPdf);
}
// multi_attribute_demand ... DEMAND2ORDER function
// append the requestDate onto the end of the dmeandName string
std::string
LgFrMultiPlantHelper::expandDemandKeyforD2O(const std::string & geoPreD2O, const std::string & requestDate)
const
{
// start with the original demand key
std::string expandedDemandName(geoPreD2O);
expandedDemandName = expandedDemandName + multiAttributeDemandSeparator_ + requestDate;
return expandedDemandName;
}
// SCE 6.1
// multi_attribute_demand ... DEMAND2ORDER function
// append the requestDate onto the end of the dmeandName string
std::string
LgFrMultiPlantHelper::expandDemandKeyforD2O(const std::string & geoPreD2O,
const std::string & requestDate,
const std::string & sourceLoc)
const
{
// start with the original demand key
std::string expandedDemandName(geoPreD2O);
expandedDemandName =
sourceLoc + multiAttributeDemandSeparator_ +
expandedDemandName + multiAttributeDemandSeparator_ +
requestDate;
return expandedDemandName;
}
std::string
LgFrMultiPlantHelper::sourceLoc(const std::string & d2oGeo)
const
{
SCETokenizer next(d2oGeo);
return next(multiAttributeDemandSeparator_.c_str());
}
// multi_attribute_demand
std::string
LgFrMultiPlantHelper::compressedDemandName(const std::string * demandAttributes[])
const
{
std::string demandName("");
int t = 0;
for (t=0; t<numDemandAttributes_-1; t++) {
demandName = demandName + multiAttributeDemandSeparator_;
}
demandName = demandName + (*demandAttributes)[numDemandAttributes_-1];
return demandName;
}
// multi_attribute_demand
void
LgFrMultiPlantHelper::compressedDemandName(std::string & demandName,
const std::string & customerLoc,
const std::string & demandClass,
const std::string & demandLevel,
const std::string & partClass)
{
demandName =
customerLoc + multiAttributeDemandSeparator_
+ demandClass + multiAttributeDemandSeparator_
+ demandLevel + multiAttributeDemandSeparator_
+ partClass;
}
// returns 0 if unsuccessful, 1 if successful
int
LgFrMultiPlantHelper::uncompressedDemandNames(
const std::string & compressedDemandName,
std::string & customerLoc,
std::string & demandClass,
std::string & demandLevel,
std::string & partClass)
{
SCETokenizer next(compressedDemandName);
// customerLoc
customerLoc = next(multiAttributeDemandSeparator_.c_str());
if (customerLoc.empty())
return 0;
// demandClass
demandClass = next(multiAttributeDemandSeparator_.c_str());
if (demandClass.empty())
return 0;
// demandLevel
demandLevel = next(multiAttributeDemandSeparator_.c_str());
if (demandLevel.empty())
return 0;
// partClass
partClass = next(multiAttributeDemandSeparator_.c_str());
if (partClass.empty())
return 0;
return 1;
}
// SCE 6.1
// returns a String Suitable for printing as leadingString
// note that it does not expect part and pdf to be in the
// compressed name
// returns 0 if unsuccessful, 1 if successful
int
LgFrMultiPlantHelper::populateLeadingString(
const std::string & partname,
const std::string & pdf,
const std::string & compressedDemandName,
std::string & leadingString)
{
if (useMultiAttributeDemand_) {
SCETokenizer next(compressedDemandName);
leadingString = "\""
+ partname + "\",\""
+ pdf + "\",";
int a;
for (a=0; a<numDemandAttributes_; a++) {
std::string nextToken = next(multiAttributeDemandSeparator_.c_str());
if (nextToken.empty()) {
return 0;
}
if (a>0) {
leadingString += ",";
}
leadingString += "\"" + nextToken + "\"";
}
return 1;
}
else {
leadingString = "\""
+ partname + "\",\""
+ pdf + "\",\"" + compressedDemandName + "\"";
}
}
// SCE 6.1
// returns a String Suitable for printing as leadingString for INDP Demand Records
// note that it does not expect part and pdf to be in the compressed name
// returns 0 if unsuccessful, 1 if successful
// Note: if "useDemand2OrderINDP"=TRUE then we add the requestDate from the demandKey
// else it is the responsibility of the calling function to append the right request (and commit) date
int
LgFrMultiPlantHelper::populateLeadingStringINDP(
const std::string & partname,
const std::string & pdf,
const std::string & demandName,
std::string & leadingString)
{
if (useMultiAttributeDemand_) {
SCETokenizer next(demandName);
leadingString = "\""
+ partname + "\",\""
+ pdf + "\",";
int a;
// !!! Demand to Order has extra key so we go numDemandAttributes_+1
for (a=0; a<numDemandAttributes_; a++) {
std::string nextToken = next(multiAttributeDemandSeparator_.c_str());
if (nextToken.empty()) {
return 0;
}
if (a>0) {
leadingString += ",";
}
leadingString += "\"" + nextToken + "\"";
}
if (useDemand2OrderINDP_) {
// pull the request date off the token and write it without quotes
std::string nextToken = next(multiAttributeDemandSeparator_.c_str());
if (nextToken.empty()) {
return 0;
}
leadingString += "," + nextToken;
}
return 1;
}
else {
leadingString = "\""
+ partname + "\",\""
+ pdf + "\",\""
+ demandName + "\"";
}
}
// returns a String Suitable for printing as leadingString
// note that it does not expect part and pdf to be in the
// compressed name
// returns 0 if unsuccessful, 1 if successful
int
LgFrMultiPlantHelper::populateLeadingStringGPD(
const std::string & partname,
const std::string & geo,
std::string & leadingString)
{
if (useMultiAttributeDemand_) {
SCETokenizer next(geo);
leadingString = "\""
+ partname + "\",";
int a;
// !!! Demand to Order has extra key so we go numDemandAttributes_+1
for (a=0; a<=numDemandAttributes_; a++) {
std::string nextToken = next(multiAttributeDemandSeparator_.c_str());
if (nextToken.empty()) {
return 0;
}
if (a>0) {
leadingString += ",";
}
leadingString += "\"" + nextToken + "\"";
}
// pull the request date off the token and write it without quotes
std::string nextToken = next(multiAttributeDemandSeparator_.c_str());
if (nextToken.empty()) {
return 0;
}
leadingString += "," + nextToken;
return 1;
}
else {
leadingString = "\""
+ partname + "\",\""
+ geo + "\"";
}
}
// multi_attribute_demand
void
LgFrMultiPlantHelper::compressedDemandNameWitPdf(std::string & demandName,
const std::string & sourceLoc,
const std::string & customerLoc,
const std::string & demandClass,
const std::string & demandLevel,
const std::string & partClass)
{
demandName =
sourceLoc + multiAttributeDemandSeparator_
+ customerLoc + multiAttributeDemandSeparator_
+ demandClass + multiAttributeDemandSeparator_
+ demandLevel + multiAttributeDemandSeparator_
+ partClass;
}
// returns 0 if unsuccessful, 1 if successful
int
LgFrMultiPlantHelper::uncompressedDemandNamesWithPdf(const std::string & compressedDemandName,
std::string & sourceLoc,
std::string & customerLoc,
std::string & demandClass,
std::string & demandLevel,
std::string & partClass)
{
SCETokenizer next(compressedDemandName);
// sourceLoc
sourceLoc = next(multiAttributeDemandSeparator_.c_str());
if (sourceLoc.empty())
return 0;
// customerLoc
customerLoc = next(multiAttributeDemandSeparator_.c_str());
if (customerLoc.empty())
return 0;
// demandClass
demandClass = next(multiAttributeDemandSeparator_.c_str());
if (demandClass.empty())
return 0;
// demandLevel
demandLevel = next(multiAttributeDemandSeparator_.c_str());
if (demandLevel.empty())
return 0;
// partClass
partClass = next(multiAttributeDemandSeparator_.c_str());
if (partClass.empty())
return 0;
return 1;
}
#if 1
// #ifdef VARIABLE_PERIODS
// set the CycleTimeDays exactly as input from Cycle Time File
void
LgFrMultiPlantHelper::setCycleTimeDays(
WitRun * const theWitRun,
const std::string & fullWitPartname,
LgFrTimeVecFloat & cycleTimeDays)
{
LgFrScePartAppData * partAppDataPtr;
witGetPartAppData (theWitRun, fullWitPartname.c_str(), (void **) &partAppDataPtr );
// if no app data exists, then create one.
if (partAppDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
partAppDataPtr = new LgFrScePartAppData(0, nPeriods, nPeriods);
}
partAppDataPtr->cycleTimeDays(cycleTimeDays);
witSetPartAppData(theWitRun, fullWitPartname.c_str(), (void *) partAppDataPtr);
}
// get the CycleTimeDays (exactly as input from Cycle Time File)
LgFrTimeVecFloat
LgFrMultiPlantHelper::getCycleTimeDays(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * partAppDataPtr;
witGetPartAppData (theWitRun, fullWitPartname.c_str(), (void **) &partAppDataPtr );
// if no app data exists, then return 0 vec
if (partAppDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
LgFrTimeVecFloat zeroVec((size_t) nPeriods, 0.0);
return zeroVec;
}
return partAppDataPtr->cycleTimeDays();
}
// set the calculated CycleTime Periods based on Variable Period Logic
// this does NOT set it in WIT ... only in partAppData
void
LgFrMultiPlantHelper::setCycleTime(
WitRun * const theWitRun,
const std::string & fullWitPartname,
LgFrTimeVecFloat & cycleTime)
{
LgFrScePartAppData * partAppDataPtr;
witGetPartAppData (theWitRun, fullWitPartname.c_str(), (void **) &partAppDataPtr );
// if no app data exists, then create one.
if (partAppDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
partAppDataPtr = new LgFrScePartAppData(0, nPeriods, nPeriods);
}
partAppDataPtr->cycleTime(cycleTime);
witSetPartAppData(theWitRun, fullWitPartname.c_str(), (void *) partAppDataPtr);
}
// get the CycleTime from App Data
LgFrTimeVecFloat
LgFrMultiPlantHelper::getCycleTime(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * partAppDataPtr;
witGetPartAppData (theWitRun, fullWitPartname.c_str(), (void **) &partAppDataPtr );
// if no app data exists, then return 0 vec
if (partAppDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
LgFrTimeVecFloat zeroVec((size_t) nPeriods, 0.0);
return zeroVec;
}
return partAppDataPtr->cycleTime();
}
float
LgFrMultiPlantHelper::calculateVariableOffset(float cycleTimeDaysToAllocate,
int t,
LgFrTimeVecFloat & workingDays,
int nPeriods)
{
float computedCycleTime = 0.0;
// two seperate loops going either forward or back in time depending on whether
// offset is positive or negative. Whoa, I think this is wrong. the positive offset
// should go from period tt=t down to 0, not, tt=t up to nPeriods. Lkewise for negatives
// it should go from tt=t to nperiods-1. also need to put in logic to truncOffsetToEol
// CASE 1: Zero Offset
if ((0.0001 < cycleTimeDaysToAllocate) && (cycleTimeDaysToAllocate < 0.0001)) {
return 0.0f;
}
// CASE 2: Positive Offset
if (cycleTimeDaysToAllocate >= 0.0001) {
int tt =0;
for (tt=t; tt>=0; tt--) {
if (cycleTimeDaysToAllocate <= workingDays[tt]) {
// float percentThreshRoll = .20;
// FINISH_ME: we can adjust fractional to integer a this point based on rules
computedCycleTime += cycleTimeDaysToAllocate/workingDays[tt];
return computedCycleTime;
}
else {
computedCycleTime += 1.0;
cycleTimeDaysToAllocate -= workingDays[tt];
}
}
// if you get to the beginning of horizon and still haven't worked off the cycleTimeDaysToAllocate,
// then we use the first period with workingDays > 0 as the assumed workingDays for past periods.
if (cycleTimeDaysToAllocate > 0.0) {
// didn't work it all off. Can't build in this period
// lets go back to last period with positive working days and use that as basis for future period lengths
for (tt=0; tt < nPeriods; tt++) {
if (workingDays[tt] > 0) {
computedCycleTime += cycleTimeDaysToAllocate/workingDays[tt];
return computedCycleTime;
}
}
return nPeriods+1;
}
}
// CASE 3: Negative Offset
else {
int tt =0;
for (tt=t; tt<nPeriods; tt++) {
if (-cycleTimeDaysToAllocate <= workingDays[tt]) {
// float percentThreshRoll = .20;
// FINISH_ME: we can adjust fractional to integer a this point based on rules
computedCycleTime += cycleTimeDaysToAllocate/workingDays[tt];
if (truncOffsetToEol_)
if (t - computedCycleTime > nPeriods - 1) {
computedCycleTime = t - (nPeriods - 1);
}
return computedCycleTime;
}
else {
computedCycleTime -= 1.0;
cycleTimeDaysToAllocate += workingDays[tt];
}
}
// if you get to beginning of horizon and still ahven't worked off the days, then we need to
// estimate this last offset.
if (cycleTimeDaysToAllocate < 0.0) {
for (tt=nPeriods-1; tt>=0; tt--) {
if (workingDays[tt] > 0) {
computedCycleTime += cycleTimeDaysToAllocate/workingDays[tt];
if (truncOffsetToEol_)
if (t - computedCycleTime > nPeriods - 1) {
computedCycleTime = t - (nPeriods - 1);
}
return computedCycleTime;
}
}
return -nPeriods;
}
}
}
float
LgFrMultiPlantHelper::calculateVariableOffset(float cycleTimeDaysToAllocate,
int t,
const LgFrCalendar & theCal,
int nPeriods)
{
int tt;
LgFrTimeVecFloat workingDays(nPeriods, 0.0);
for (tt=0; tt < nPeriods; tt++) {
workingDays[tt] = theCal.workUnits(tt);
}
return this->calculateVariableOffset(cycleTimeDaysToAllocate, t, workingDays, nPeriods);
}
#endif
// =============================
// =============================
// END of SCE 6.1
// =============================
// =============================
// default constructor:
LgFrMultiPlantHelper::LgFrMultiPlantHelper()
: pdfSeparator_("? \t\n"),
defaultPdf_("WW"),
useMultiAttributeDemand_(0),
numDemandAttributes_(4),
multiAttributeDemandSeparator_("% \t\n"),
useDemand2OrderINDP_(0),
truncOffsetToEol_(0),
sceErrFacility_(0)
{
// all the work is done in initializer
}
// fairly general constructor:
LgFrMultiPlantHelper::LgFrMultiPlantHelper(
const std::string & pdfSeparator,
const std::string & defaultPdf,
const bool useMultiAttributeDemand,
const int numDemandAttributes,
const std::string & multiAttributeDemandSeparator,
const bool useDemand2OrderINDP)
: pdfSeparator_(pdfSeparator),
defaultPdf_(defaultPdf),
useMultiAttributeDemand_(useMultiAttributeDemand),
numDemandAttributes_(numDemandAttributes),
multiAttributeDemandSeparator_(multiAttributeDemandSeparator),
useDemand2OrderINDP_(useDemand2OrderINDP),
truncOffsetToEol_(0),
sceErrFacility_(0)
{
// all the work is done in initializer
}
// necessary methods for sharing scenario's error facility
void
LgFrMultiPlantHelper::setErrFacility(MclFacility * existingFacility)
{
sceErrFacility_ = existingFacility;
}
MclFacility*
LgFrMultiPlantHelper::getErrFacility()
{
return sceErrFacility_;
}
#ifdef ENABLE_NEGATIVE_DEMANDS
// Return 1 if part has any negative demands
int
LgFrMultiPlantHelper::doesPartHaveNegativeDemands(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->doesPartHaveNegativeDemands();
}
// Set the Part's doesPartHaveNegativeDemands
void
LgFrMultiPlantHelper::setDoesPartHaveNegativeDemands(
WitRun * const theWitRun,
const std::string & fullWitPartname,
int doesPartHaveNegativeDemands)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
// if hte part does not have an appData, then create one
if (appDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
appDataPtr = new LgFrScePartAppData(0, nPeriods, nPeriods);
witSetPartAppData(theWitRun, fullWitPartname.c_str(), (void *) appDataPtr);
}
appDataPtr->doesPartHaveNegativeDemands(doesPartHaveNegativeDemands);
}
LgFrTimeVecFloat
LgFrMultiPlantHelper::negDemVol(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
int nPeriods;
int nDemands;
char ** dList;
float * witDemandVol;
witGetNPeriods(theWitRun, &nPeriods);
LgFrTimeVecFloat negDemVol((size_t) nPeriods, 0.0);
LgFrSceDemandAppData * appDataPtr = 0;
if (this->doesPartHaveNegativeDemands(theWitRun, fullWitPartname)) {
int didWeFindAnAppData = 0;
witGetPartDemands(theWitRun, fullWitPartname.c_str(), &nDemands, &dList);
int j = 0; // Pulled out of the for below by RW2STL
for (j=0; j<nDemands; j++) {
witGetDemandDemandVol(theWitRun, fullWitPartname.c_str(), dList[j], &witDemandVol);
witGetDemandAppData(theWitRun, fullWitPartname.c_str(), dList[j], (void **) &appDataPtr);
if (appDataPtr != 0) {
didWeFindAnAppData = 1;
LgFrTimeVecFloat appDataDemandVol(appDataPtr->demandVol());
int t = 0; // Pulled out of the for below by RW2STL
for (t=0; t<nPeriods; t++) {
negDemVol[t] += witDemandVol[t] - appDataDemandVol[t];
}
}
witFree(witDemandVol);
witFree(dList[j]);
}
witFree(dList);
if (! didWeFindAnAppData) {
std::cerr << "SCE9955F PROGRAMMER ERROR: part with negative demands does not\n"
<< "have a demand with non-0 appData\n"
<< "Please report this error to SCE Development\n"
<< "SCE Terminates with return code: 8\n\n";
exit(8);
}
}
return negDemVol;
}
#endif
// Return 1 if a part is marked as a PCF part, 0 if not
int
LgFrMultiPlantHelper::isPartPcf(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (! exists)
return 0;
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->isPartPcf();
}
#ifdef MARK_BOGONS
// Return 1 if a part is a PCF bogon
int
LgFrMultiPlantHelper::isPartBogon(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->isPartBogon();
}
#endif
// Return the witPartIndex
// returns -1 if the part is bad, or, index is not set
int
LgFrMultiPlantHelper::witPartIndex(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return -1;
return appDataPtr->index();
}
// Return the witOperationIndex
// returns -1 if the operation is bad, or, index is not set
int
LgFrMultiPlantHelper::witOperationIndex(
WitRun * const theWitRun,
const std::string & fullWitOperationName)
{
LgFrSceCCOperationAppData * appDataPtr;
witGetOperationAppData(theWitRun, fullWitOperationName.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return -1;
return appDataPtr->index();
}
// (Re)set the partAppData indices to synch with a witGetParts()
// It sets them for all parts and re-sets if an appData already exists
void
LgFrMultiPlantHelper::setAllWitPartIndices(
WitRun * const theWitRun)
{
int nParts;
char ** partList;
witGetParts (theWitRun, &nParts, &partList );
int i = 0; // Pulled out of the for below by RW2STL
for (i=0; i<nParts; i++) {
LgFrScePartAppData * partAppDataPtr;
witGetPartAppData (theWitRun, partList[i], (void **) &partAppDataPtr );
// if no app data exists, then create one.
if (partAppDataPtr == 0) {
int nPeriods;
witGetNPeriods(theWitRun, &nPeriods);
partAppDataPtr = new LgFrScePartAppData(0, nPeriods, nPeriods);
witSetPartAppData(theWitRun, partList[i], (void *) partAppDataPtr);
}
partAppDataPtr->index(i);
}
for (i=0; i<nParts; i++)
witFree (partList[i]);
witFree (partList);
}
// set the Customer Choice Operation AppData indices to synch with a witGetOperation()
// It sets them only for Special Customer Choice feature parts
void
LgFrMultiPlantHelper::setCCOperationIndices(
WitRun * const theWitRun)
{
int nOperations;
char ** opList;
std::string geo;
std::string machine;
std::string pdf;
std::string featurePart;
witGetOperations (theWitRun, &nOperations, &opList );
int o = 0; // Pulled out of the for below by RW2STL
for (o=0; o<nOperations; o++) {
if (! this->isOperationSpecialCustChoiceFeature(theWitRun, opList[o], geo, machine,pdf,featurePart)) {
witFree(opList[o]);
continue;
}
LgFrSceCCOperationAppData * ccOpAppDataPtr;
witGetOperationAppData (theWitRun, opList[o], (void **) &ccOpAppDataPtr );
// if no app data exists, then create one.
if (ccOpAppDataPtr == 0) {
ccOpAppDataPtr = new LgFrSceCCOperationAppData(o);
witSetOperationAppData(theWitRun, opList[o], (void *) ccOpAppDataPtr);
}
ccOpAppDataPtr->index(o);
witFree(opList[o]);
}
witFree (opList);
}
// returns the feature ratio of a customer choice feature.
// Note that the partname MUST be a specialCustChoicePartName
LgFrTimeVecFloat
LgFrMultiPlantHelper::custChoiceFeatureRatio(
WitRun * const theWitRun,
const std::string & specialCustChoiceFeature)
{
std::string geo, plannerTopLevelPart, pppdf, featurePart;
assert(this->isPartSpecialCustChoiceFeature(theWitRun, specialCustChoiceFeature, geo,
plannerTopLevelPart, pppdf,
featurePart));
// Now get the unique bomEntry between this specialCustChoiceFeature and GPD
int ncbe;
witGetPartNConsumingBomEntries(theWitRun, specialCustChoiceFeature.c_str(), &ncbe);
// FINISH_ME: this does not work for multiple geo sourcing
assert(ncbe == 1);
char * gpdWitOperationName;
int bomIndex;
witGetPartConsumingBomEntry(theWitRun, specialCustChoiceFeature.c_str(), 0, &gpdWitOperationName, &bomIndex);
LgFrSceCustChoiceBomAppData * bomAppDataPtr;
witGetBomEntryAppData(theWitRun, gpdWitOperationName, bomIndex, (void **) &bomAppDataPtr);
assert(bomAppDataPtr != 0);
witFree(gpdWitOperationName);
return bomAppDataPtr->featRatio();
}
// GET
// this helper goes into wit and finds the right appdata
// for the Dummysupply Adjustment to be used in MRP
LgFrTimeVecFloat
LgFrMultiPlantHelper::custChoiceDummySupplyVolForMrpAdjustment(
WitRun * const theWitRun,
const std::string & specialCustChoiceFeature)
{
std::string geo, plannerTopLevelPart, pppdf, featurePart;
assert(this->isPartSpecialCustChoiceFeature(theWitRun, specialCustChoiceFeature, geo,
plannerTopLevelPart, pppdf,
featurePart));
// Now get the unique bomEntry between this specialCustChoiceFeature and GPD
int ncbe;
witGetPartNConsumingBomEntries(theWitRun, specialCustChoiceFeature.c_str(), &ncbe);
// FINISH_ME: this does not work for multiple geo sourcing
assert(ncbe == 1);
char * gpdWitOperationName;
int bomIndex;
witGetPartConsumingBomEntry(theWitRun, specialCustChoiceFeature.c_str(), 0, &gpdWitOperationName, &bomIndex);
LgFrSceCustChoiceBomAppData * bomAppDataPtr;
witGetBomEntryAppData(theWitRun, gpdWitOperationName, bomIndex, (void **) &bomAppDataPtr);
assert(bomAppDataPtr != 0);
witFree(gpdWitOperationName);
return bomAppDataPtr->dummySupplyVolForMrpAdjustment();
}
// SET
// this helper goes into wit and finds the right appdata
// for the Dummysupply Adjustment to be used in MRP
void
LgFrMultiPlantHelper::custChoiceDummySupplyVolForMrpAdjustment(
WitRun * const theWitRun,
const std::string & specialCustChoiceFeature,
LgFrTimeVecFloat & dummySupplyVolForMrpAdjustment)
{
std::string geo, plannerTopLevelPart, pppdf, featurePart;
assert(this->isPartSpecialCustChoiceFeature(theWitRun, specialCustChoiceFeature, geo,
plannerTopLevelPart, pppdf,
featurePart));
// Now get the unique bomEntry between this specialCustChoiceFeature and GPD
int ncbe;
witGetPartNConsumingBomEntries(theWitRun, specialCustChoiceFeature.c_str(), &ncbe);
// FINISH_ME: this does not work for multiple geo sourcing
assert(ncbe == 1);
char * gpdWitOperationName;
int bomIndex;
witGetPartConsumingBomEntry(theWitRun, specialCustChoiceFeature.c_str(), 0, &gpdWitOperationName, &bomIndex);
LgFrSceCustChoiceBomAppData * bomAppDataPtr;
witGetBomEntryAppData(theWitRun, gpdWitOperationName, bomIndex, (void **) &bomAppDataPtr);
assert(bomAppDataPtr != 0);
witFree(gpdWitOperationName);
bomAppDataPtr->dummySupplyVolForMrpAdjustment(dummySupplyVolForMrpAdjustment);
}
// returns convenient way to get the nInterplant Ops
int
LgFrMultiPlantHelper::nInterplantOps(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->nInterplantOps();
}
// returns convenient way to get the nAlternatePart Ops
int
LgFrMultiPlantHelper::nAlternatePartOps(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->nAlternatePartOps();
}
// returns convenient way to get the nUserDefinedOps
int
LgFrMultiPlantHelper::nUserDefinedOps(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->nUserDefinedOps();
}
// returns convenient way to get the nAggregationOps
int
LgFrMultiPlantHelper::nAggregationOps(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
LgFrScePartAppData * appDataPtr;
witGetPartAppData(theWitRun, fullWitPartname.c_str(), (void **) &appDataPtr);
if (appDataPtr == 0)
return 0;
return appDataPtr->nAggregationOps();
}
std::string
LgFrMultiPlantHelper::pdfPartname(
const std::string & part,
const std::string & pdf)
const
{
return pdf + pdfSeparator_ + this->partname(part);
}
std::string
LgFrMultiPlantHelper::pdfOperationName(
const std::string & operation,
const std::string & pdf)
const
{
return pdf + pdfSeparator_ + this->operationName(operation);
}
// Return a demand_Geo name, given the demand, geo
std::string
LgFrMultiPlantHelper::geoPlannerDemandPartName(
const std::string & plannerPart,
const std::string & geo)
const
{
return
geo
+ pdfSeparator_
+ plannerPart
+ pdfSeparator_
+ "specialGeoPlannerDemand";
}
// Return a demand_GeoUB name, given the demand, geo
std::string
LgFrMultiPlantHelper::geoPlannerDemandUbPartName(
const std::string & plannerPart,
const std::string & geo)
const
{
return
geo
+ pdfSeparator_
+ plannerPart
+ pdfSeparator_
+ "specialGeoPlannerDemandUB";
}
// Return a interplant operation name, given the parent, parentPdf,
// child, childPdf
std::string
LgFrMultiPlantHelper::interPlantOperationName(
const std::string & parentMfgPart,
const std::string & parentPdf,
const std::string & childMfgPart,
const std::string & childPdf)
const
{
return
parentPdf +
pdfSeparator_ +
parentMfgPart +
pdfSeparator_ +
childPdf +
pdfSeparator_ +
childMfgPart +
pdfSeparator_ +
"specialInterPlantOperation";
}
// Return a alternate operation name, given the parent, parentPdf,
// child, childPdf
std::string
LgFrMultiPlantHelper::alternatePartOperationName(
const std::string & primePart,
const std::string & primePdf,
const std::string & altPart,
const std::string & altPdf)
const
{
return
primePdf +
pdfSeparator_ +
primePart +
pdfSeparator_ +
altPdf +
pdfSeparator_ +
altPart +
pdfSeparator_ +
"specialAlternatePartOperation";
}
#if 0
// this is obsolete, replaced by operationForCapacityGeneration
// Return an operation name for the purpose of a modelling trick in Smart Exploder
std::string
LgFrMultiPlantHelper::operationForSmartExploderCapacity(
const std::string & theFullCapacityName)
const
{
return
theFullCapacityName +
pdfSeparator_ +
"specialSmartExplodeCapacityOperation";
}
#endif
// Return an operation name for generating capacity
std::string
LgFrMultiPlantHelper::operationForCapacityGeneration(
const std::string & theFullCapacityName)
const
{
return
theFullCapacityName +
pdfSeparator_ +
"specialOperationForCapacityGeneration";
}
// Return a aggregation operation name, given the realPart, realPartPdf
// aggPart, and aggPdf
std::string
LgFrMultiPlantHelper::aggregationOperationName(
const std::string & realPart,
const std::string & realPartPdf,
const std::string & aggPart,
const std::string & aggPdf)
const
{
return
realPartPdf +
pdfSeparator_ +
realPart +
pdfSeparator_ +
aggPdf +
pdfSeparator_ +
aggPart +
pdfSeparator_ +
"specialAggregationOperation";
}
// Return a phantom part name, given the part and pdf
std::string
LgFrMultiPlantHelper::phantomPartName(
const std::string & thePart,
const std::string & pdf)
const
{
return
pdf +
pdfSeparator_ +
thePart +
"specialPhantomPart";
}
// Return a global nullSubstitute part name, given a pdf
std::string
LgFrMultiPlantHelper::globalNullSubstitute(
const std::string & pdf)
const
{
return
pdf +
pdfSeparator_ +
"nullSub" +
pdfSeparator_ +
"specialGlobalNullSubstitute";
}
// Return a globalMaxWithoutNullSubstitute part name, given a pdf.
//
// When the maxWithoutRatio = 0.0 (so we have a "mandatory feature")
// the substitute on the gpd part to feature part arc is a global
// maxWithoutNullSubstitute, whose supply is zero. The reason for
// employing a "global" instead a distinct null sub in this case
// is to reduce the problem size (many parts in the ECA run have
// the maxWithoutRatio equal to a vector of all zeros).
std::string
LgFrMultiPlantHelper::globalMaxWithoutNullSubstitute(
const std::string & pdf)
const
{
return
pdf +
pdfSeparator_ +
"nullSub" +
pdfSeparator_ +
"specialGlobalMaxWithoutNullSubstitute";
}
// CUSTOMER_CHOICE_FEATURES
// This is the nullSubstitute to use for customer choice features
//
// Return a nullSubstitute part name, given geo, planner part and feature.
std::string
LgFrMultiPlantHelper::custChoiceNullSubstitute(
const std::string & geo,
const std::string & plannerPart,
const std::string & featurePart)
const
{
return
geo +
pdfSeparator_ +
plannerPart +
pdfSeparator_ +
featurePart +
pdfSeparator_ +
"specialCustChoiceNullSubstitute";
}
// This is the maxWithOutNullSubstitute to use when you want a unique nullSub
// for the unique pair (geo_plannerPart_"specialGeoPlannerDemand", pdf_featurePart)
//
// Because the pdf of the featurePart is function of the pdf sourcing of the plannerPart
// (and we can get it if we need it), the pdf is not encode in the maxWithoutNullSubstitute
// part name.
//
// Return a nullSubstitute part name, given geo, planner part and feature.
// NOTE: this should be used for features with MaxWithout < featratio
std::string
LgFrMultiPlantHelper::maxWithoutNullSubstitute(
const std::string & geo,
const std::string & plannerPart,
const std::string & featurePart)
const
{
return
geo +
pdfSeparator_ +
plannerPart +
pdfSeparator_ +
featurePart +
pdfSeparator_ +
"specialMaxWithoutNullSubstitute";
}
// Return a unique standalone Feature Part Name
std::string
LgFrMultiPlantHelper::custChoiceFeaturePartName(
const std::string & machine,
const std::string & geo,
const std::string & featurePart,
const std::string & pdf)
const
{
return
geo +
pdfSeparator_ +
machine +
pdfSeparator_ +
pdf +
pdfSeparator_ +
featurePart +
pdfSeparator_ +
"specialCustChoiceFeature";
}
// Returns 1 if part is a special Cust Choice Feature, 0 otherwise
// If returns 1, also sets the geo, the plannerPart, pdf, and featurePart
int
LgFrMultiPlantHelper::isPartSpecialCustChoiceFeature(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & geo,
std::string & machine,
std::string & pdf,
std::string & featurePart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialCustChoiceFeature")
return 1;
return 0;
}
// Returns 1 if operation is a special Customer Choice Feature, 0 otherwise
// If returns 1, also sets the geo, the plannerPart, pdf, and featurePart
int
LgFrMultiPlantHelper::isOperationSpecialCustChoiceFeature(
WitRun * const theWitRun,
const std::string & fullWitOperation,
std::string & geo,
std::string & machine,
std::string & pdf,
std::string & featurePart)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperation.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperation);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialCustChoiceFeature")
return 1;
return 0;
}
// Returns 1 if operation is EITHER:
// special Standalone Feature,
// OR special Customer Choice Feature,
// 0 otherwise
// If returns 1, also sets the geo, the plannerPart, pdf, and featurePart
int
LgFrMultiPlantHelper::isOperationSpecialFeature(
WitRun * const theWitRun,
const std::string & fullWitOperation,
std::string & geo,
std::string & machine,
std::string & pdf,
std::string & featurePart)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperation.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperation);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if ((anythingSpecial == "specialStandaloneFeature")
||
(anythingSpecial == "specialCustChoiceFeature"))
return 1;
return 0;
}
// Returns 1 if part is a special Standalone Feature, 0 otherwise
// (overloaded function. this one just checks ...
int
LgFrMultiPlantHelper::isPartSpecialCustChoiceFeature(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
std::string geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
std::string machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
std::string pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
std::string featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialCustChoiceFeature")
return 1;
return 0;
}
// Returns 1 if part is EITHER:
// special Standalone Feature,
// OR special Customer Choice Feature,
// 0 otherwise
// (overloaded function. this one just checks ...
int
LgFrMultiPlantHelper::isPartSpecialFeature(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
std::string geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
std::string machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
std::string pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
std::string featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if ((anythingSpecial == "specialCustChoiceFeature")
||
(anythingSpecial == "specialStandaloneFeature"))
return 1;
return 0;
}
// Return a unique standalone Feature Part Name
std::string
LgFrMultiPlantHelper::standaloneFeaturePartName(
const std::string & machine,
const std::string & geo,
const std::string & featurePart,
const std::string & pdf)
const
{
return
geo +
pdfSeparator_ +
machine +
pdfSeparator_ +
pdf +
pdfSeparator_ +
featurePart +
pdfSeparator_ +
"specialStandaloneFeature";
}
// Return a unique bbCategory part name
std::string
LgFrMultiPlantHelper::bbCategoryPartName(
const std::string & plannerTopLevelBuild,
const std::string & geo,
const std::string & bbCategory)
const
{
return
geo +
pdfSeparator_ +
plannerTopLevelBuild +
pdfSeparator_ +
bbCategory +
pdfSeparator_ +
"specialBbCategory";
}
// Return a unique part name for LT Feature Set Capacity Part
std::string
LgFrMultiPlantHelper::LTbbCapacityPartName(
const std::string & plannerTopLevelBuild,
const std::string & geo,
const std::string & bbCategory)
const
{
return
geo +
pdfSeparator_ +
plannerTopLevelBuild +
pdfSeparator_ +
bbCategory +
pdfSeparator_ +
"specialLTFeatureCapacity";
}
// Return a unique part name for GT Feature Set Capacity Part
std::string
LgFrMultiPlantHelper::GTbbCapacityPartName(
const std::string & plannerTopLevelBuild,
const std::string & geo,
const std::string & bbCategory)
const
{
return
geo +
pdfSeparator_ +
plannerTopLevelBuild +
pdfSeparator_ +
bbCategory +
pdfSeparator_ +
"specialGTFeatureCapacity";
}
// Return a unique part name for an Option Dummy part
std::string
LgFrMultiPlantHelper::optionDummyPartName(
const std::string & plannerTopLevelBuild,
const std::string & geo,
const std::string & bbCategory,
const std::string & option)
const
{
return
geo +
pdfSeparator_ +
plannerTopLevelBuild +
pdfSeparator_ +
bbCategory +
pdfSeparator_ +
option +
pdfSeparator_ +
"specialOptionDummy";
}
// Return a unique part name for an Option Ratio Supply part
std::string
LgFrMultiPlantHelper::optionRatioSupplyPartName(
const std::string & plannerTopLevelBuild,
const std::string & geo,
const std::string & bbCategory,
const std::string & option)
const
{
return
geo +
pdfSeparator_ +
plannerTopLevelBuild +
pdfSeparator_ +
bbCategory +
pdfSeparator_ +
option +
pdfSeparator_ +
"specialOptionRatioSupply";
}
#if 0
// Return the partType of the part
// 1 = Normal
// 2 = Aggragate dummy
// 3 = BB/feature set dummy
int
LgFrMultiPlantHelper::partType(const std::string & pdfPart)
const
{
return 1; // that's it for now
}
// Return the partType of the part
// 1 = Normal
// 2 = Aggragate dummy
// 3 = BB/feature set dummy
int
LgFrMultiPlantHelper::partType(const std::string & part, const std::string & pdf)
const
{
return this->partType(pdf + this->pdfSeparator_ + pdf);
}
#endif
// Return 1 if good, 0 if bad
int
LgFrMultiPlantHelper::isPartValid(
WitRun * const theWitRun,
const std::string & partName,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
const
{
witBoolean exists;
witGetPartExists(theWitRun, partName.c_str(), &exists);
if (exists == WitFALSE && messageLogic == MANDATORY) {
(*sceErrFacility_)("UnrecognizedPartError",MclArgList()
<< partName
<< fileName
<< (int)lineNo
<< dataLine);
// exits
}
if (exists == WitFALSE && messageLogic == OPTIONAL_WITH_MESSAGE) {
(*sceErrFacility_)("UnrecognizedPartWarning",MclArgList() << partName << fileName << (int)lineNo << dataLine);
return 0;
}
if (exists == WitFALSE)
return 0;
return 1;
}
// Return 1 if good, 0 if bad
int
LgFrMultiPlantHelper::isPartValid(
WitRun * const theWitRun,
const std::string & part,
const std::string & pdf,
const std::string & filename,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
const
{
std::string pdfPart = pdf + pdfSeparator_ + part;
witBoolean exists;
exists = this->isPartValid(theWitRun, pdfPart, filename, dataLine, lineNo, PURELY_OPTIONAL);
if (exists == WitFALSE && messageLogic == MANDATORY) {
(*sceErrFacility_)("UnrecognizedPartPdfError",MclArgList()
<< part << pdf << filename << (int)lineNo << dataLine);
// exits
}
if (exists == WitFALSE && messageLogic == OPTIONAL_WITH_MESSAGE) {
(*sceErrFacility_)("UnrecognizedPartPdfWarning",MclArgList()
<< part << pdf << filename << (int)lineNo << dataLine);
return 0;
}
if (exists == WitFALSE)
return 0;
return 1;
}
// Return 1 if a normal (no special characters) part, 0 if not
// SCE tidbit:
// "normal" parts in SCE have two pieces to their name
// all other special modeling parts have three or more
// pieces to their name. --RLH
int
LgFrMultiPlantHelper::isPartNormal(
WitRun * const theWitRun,
const std::string & fullWitPartname)
const
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
std::string thePdf = next(pdfSeparator_.c_str());
assert (! thePdf.empty());
std::string thePartName = next(pdfSeparator_.c_str());
assert (! thePartName.empty());
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial.empty())
return 1;
return 0;
}
//
// Return 1 if a "normal" (no special characters) operation, 0 otherwise.
// If method returns 1, the method also sets the pdf and operation
// "Normal" here means that either (1) the operation was defined
// explicitedly by the user via the Operation Definition File or
// (2) SCE generated the operation from a part that was explicitedly
// defined by the user via the Part Definition File.
// SCE tidbit:
// "normal" operations in SCE have two pieces to their name
// all other special modeling operation have three or more
// pieces to their name. --RLH
// Note: if you want to find out if the operation is specifically a
// UserDefined Operation, then use isOperationUserDefined()
int
LgFrMultiPlantHelper::isOperationNormal(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & thePdf,
std::string & theOperationName)
const
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
thePdf = next(pdfSeparator_.c_str());
if (thePdf.empty())
return 0;
theOperationName = next(pdfSeparator_.c_str());
if (theOperationName.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial.empty())
return 1;
return 0;
}
//
// Return 1 if the operation is "User Defined", 0 ow.
// If method returns 1, the method also sets the pdf and operation
int
LgFrMultiPlantHelper::isOperationUserDefined(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & thePdf,
std::string & theOperationName)
const
{
if (this->isOperationNormal(theWitRun, fullWitOperationName, thePdf, theOperationName)) {
if (this->isPartNormal(theWitRun, fullWitOperationName))
return 0;
else
return 1;
}
else
return 0;
}
// Return 1 if a normal (no special characters) capacity, 0 if not
int
LgFrMultiPlantHelper::isPartNormalCapacity(
WitRun * const theWitRun,
const std::string & fullWitPartname)
const
{
witBoolean exists;
witAttr category;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
witGetPartCategory(theWitRun, fullWitPartname.c_str(), &category);
if (category != WitCAPACITY)
return 0;
SCETokenizer next(fullWitPartname);
std::string thePdf = next(pdfSeparator_.c_str());
assert (! thePdf.empty());
std::string thePartName = next(pdfSeparator_.c_str());
assert (! thePartName.empty());
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial.empty())
return 1;
return 0;
}
// Returns 1 if part is a specialGeoPlannerDemand part, 0 otherwise
// If returns 1, also sets the plannerPart and geo
int
LgFrMultiPlantHelper::isPartSpecialGeoPlannerDemandPart(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerPart,
std::string & geo)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGeoPlannerDemand")
return 1;
return 0;
}
// Returns 1 if part is a specialGeoPlannerDemandUB part, 0 otherwise
// If returns 1, also sets the plannerPart and geo
int
LgFrMultiPlantHelper::isPartSpecialGeoPlannerDemandUbPart(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerPart,
std::string & geo)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGeoPlannerDemandUB")
return 1;
return 0;
}
// Returns 1 if operation is a special aggregation operation, 0 otherwise
// If returns 1, also sets the realPart and aggPart and pdf's
int
LgFrMultiPlantHelper::isOperationSpecialAggregation(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & realPart,
std::string & realPartPdf,
std::string & aggPart,
std::string & aggPdf)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// parentPdf
realPartPdf = next(pdfSeparator_.c_str());
if (realPartPdf.empty())
return 0;
// parent
realPart = next(pdfSeparator_.c_str());
if (realPart.empty())
return 0;
// childPdf
aggPdf = next(pdfSeparator_.c_str());
if (aggPdf.empty())
return 0;
// child
aggPart = next(pdfSeparator_.c_str());
if (aggPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialAggregationOperation")
return 1;
return 0;
}
// Returns 1 if operation is a special interplant operation, 0 otherwise
// If returns 1, also sets the destination and source part and pdf
int
LgFrMultiPlantHelper::isOperationSpecialInterplant(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & destination,
std::string & destinationPdf,
std::string & source,
std::string & sourcePdf)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// parentPdf
destinationPdf = next(pdfSeparator_.c_str());
if (destinationPdf.empty())
return 0;
// parent
destination = next(pdfSeparator_.c_str());
if (destination.empty())
return 0;
// childPdf
sourcePdf = next(pdfSeparator_.c_str());
if (sourcePdf.empty())
return 0;
// child
source = next(pdfSeparator_.c_str());
if (source.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialInterPlantOperation")
return 1;
return 0;
}
// Returns 1 if operation is a special alternate part operation, 0 otherwise
// If returns 1, also sets the primePart, primePdf, altPart, and altPdf
int
LgFrMultiPlantHelper::isOperationSpecialAlternate(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & primePart,
std::string & primePdf,
std::string & altPart,
std::string & altPdf)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// primePdf
primePdf = next(pdfSeparator_.c_str());
if (primePdf.empty())
return 0;
// primePart
primePart = next(pdfSeparator_.c_str());
if (primePart.empty())
return 0;
// altPdf
altPdf = next(pdfSeparator_.c_str());
if (altPdf.empty())
return 0;
// altPart
altPart = next(pdfSeparator_.c_str());
if (altPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialAlternatePartOperation")
return 1;
return 0;
}
// +
// Returns 1 if operation is a special interplant operation and
// sets the full pdf-part name for the source part
// Otherwise, returns 0
int
LgFrMultiPlantHelper::interplantSourcePdfPartName(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & sourcePdfPartName)
{
std::string destination;
std::string destinationPdf;
std::string source;
std::string sourcePdf;
if ( isOperationSpecialInterplant( theWitRun, fullWitOperationName,
destination, destinationPdf,
source, sourcePdf) ) {
sourcePdfPartName = pdfPartname( source, sourcePdf);
return 1;
}
sourcePdfPartName = "";
return 0;
}
// Returns 1 if part is a specialGeoPlannerDemand part, 0 otherwise
// If returns 1, also sets the plannerPart and geo
int
LgFrMultiPlantHelper::isOperationSpecialGeoPlannerDemand(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & plannerPart,
std::string & geo)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGeoPlannerDemand")
return 1;
return 0;
}
#if 0
// this is obsolete, replaced by operationForCapacityGeneration
// Return 1 if the operation is SmartExpldoer Capacity creator
int
LgFrMultiPlantHelper::isOperationSpecialSmartExploderCapacity(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & theCapacity,
std::string & pdf)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// Pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// capacity
theCapacity = next(pdfSeparator_.c_str());
if (theCapacity.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialSmartExplodeCapacityOperation")
return 1;
return 0;
}
#endif
// Return 1 if the operation is SmartExpldoer Capacity creator
int
LgFrMultiPlantHelper::isOperationForCapacityGeneration(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & theCapacity,
std::string & pdf)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// Pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// capacity
theCapacity = next(pdfSeparator_.c_str());
if (theCapacity.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialOperationForCapacityGeneration")
return 1;
return 0;
}
// Returns 1 if the is part is a globalNullSubstitute
// or a maxWithoutNullSubstitute,
// or a globalMaxWithoutNullSubstitute,
// 0 otherwise
// b/c the tokens in the names for the different types of null subs are NOT analogous,
// no information encoded in the partname is returned. If information
// encoded in the name of the nullSubstitute is needed, then you'll have to ask
// ::isPartSpecialGlobalNullSubstitute or ::isPartSpecialMaxWithoutNullSubstitute
// or ::isPartSpecialGlobalMaxWithoutNullSubstitute
// to get the null substitute name decoded properly.
//
// Use this method if you just need to know if the part is one of the three types of null subs.
//
int
LgFrMultiPlantHelper::isPartSpecialNullSubstitute(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
std::string d1,d2,d3;
if (isPartSpecialGlobalMaxWithoutNullSubstitute(theWitRun, fullWitPartname, d1))
return 1;
if (isPartSpecialMaxWithoutNullSubstitute(theWitRun, fullWitPartname, d1,d2,d3))
return 1;
if (isPartSpecialGlobalNullSubstitute(theWitRun, fullWitPartname, d1))
return 1;
// CUSTOMER_CHOICE_FEATURES
if (isPartSpecialCustChoiceNullSubstitute(theWitRun, fullWitPartname, d1,d2,d3))
return 1;
return 0;
}
// Returns 1 if part is a special Global nullSubstitiute, 0 otherwise
// If returns 1, also sets the pdf
int
LgFrMultiPlantHelper::isPartSpecialGlobalNullSubstitute(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & pdf)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// dummyPartName -- this is "nullSub", if the method returns 1.
std::string dpn = next(pdfSeparator_.c_str());
if (dpn.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGlobalNullSubstitute")
return 1;
return 0;
}
#ifdef ALTERNATE_AS_SUB
// Return a Global Alt Dummy part name
std::string
LgFrMultiPlantHelper::globalAltDummyPartName(
const std::string & primePdf)
const
{
return
primePdf +
pdfSeparator_ +
primePdf +
pdfSeparator_ +
"specialGlobalAltDummy";
}
// Returns 1 if part is a special Global Alt Dummy, 0 otherwise
// If returns 1, also sets the pdf
int
LgFrMultiPlantHelper::isPartSpecialGlobalAltDummy(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & pdf)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// pdf (appears twice)
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// dummyPartName --
std::string dpn = next(pdfSeparator_.c_str());
if (dpn.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGlobalAltDummy")
return 1;
return 0;
}
#endif
// Returns 1 if part is a special GlobalMaxWithoutNullSubstitiute,
// 0 otherwise
// If returns 1, also sets the pdf
int
LgFrMultiPlantHelper::isPartSpecialGlobalMaxWithoutNullSubstitute(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & pdf)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// dummyPartName -- this is "nullSub", if the method returns 1.
std::string dpn = next(pdfSeparator_.c_str());
if (dpn.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGlobalMaxWithoutNullSubstitute")
return 1;
return 0;
}
// Returns 1 if part is a special MaxWithout nullSubstitiute, 0 otherwise
// If returns 1, also sets the geo, the plannerPart, and featurePart
int
LgFrMultiPlantHelper::isPartSpecialMaxWithoutNullSubstitute(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & geo,
std::string & plannerPart,
std::string & featurePart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerPartName
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialMaxWithoutNullSubstitute")
return 1;
return 0;
}
// CUSTOMER_CHOICE_FEATURES
// Returns 1 if part is a special CustChoiceNullSubstitiute,
// 0 otherwise
// If returns 1, also sets the pdf
int
LgFrMultiPlantHelper::isPartSpecialCustChoiceNullSubstitute(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & geo,
std::string & plannerPart,
std::string & featurePart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerPartName
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialCustChoiceNullSubstitute")
return 1;
return 0;
}
// Returns 1 if part is a special Standalone Feature, 0 otherwise
// If returns 1, also sets the geo, the plannerPart, pdf, and featurePart
int
LgFrMultiPlantHelper::isPartSpecialStandaloneFeature(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & geo,
std::string & machine,
std::string & pdf,
std::string & featurePart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialStandaloneFeature")
return 1;
return 0;
}
// Returns 1 if operation is a special Standalone Feature, 0 otherwise
// If returns 1, also sets the geo, the plannerPart, pdf, and featurePart
int
LgFrMultiPlantHelper::isOperationSpecialStandaloneFeature(
WitRun * const theWitRun,
const std::string & fullWitOperation,
std::string & geo,
std::string & machine,
std::string & pdf,
std::string & featurePart)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperation.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperation);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialStandaloneFeature")
return 1;
return 0;
}
// Returns 1 if part is a special Standalone Feature, 0 otherwise
// (overloaded function. this one just checks ...
int
LgFrMultiPlantHelper::isPartSpecialStandaloneFeature(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
std::string geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// machine
std::string machine = next(pdfSeparator_.c_str());
if (machine.empty())
return 0;
// pdf
std::string pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// featurePartName
std::string featurePart = next(pdfSeparator_.c_str());
if (featurePart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialStandaloneFeature")
return 1;
return 0;
}
// Returns 1 if part is a special phantom part, 0 otherwise
int
LgFrMultiPlantHelper::isPartSpecialPhantom(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// Pdf
std::string pdf = next(pdfSeparator_.c_str());
if (pdf.empty())
return 0;
// part
std::string aPart = next(pdfSeparator_.c_str());
if (aPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialPhantomPart")
return 1;
return 0;
}
// Returns 1 if part is a special BB category Set part, 0 otherwise
// If returns 1, also sets the plannerTopLevelBuild, geo, and bbCategory
int
LgFrMultiPlantHelper::isPartSpecialBbCategory(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialBbCategory")
return 1;
return 0;
}
// Returns 1 if part is a special feature Set LT capacity part, 0 otherwise
// If returns 1, also sets the part and pdf
int
LgFrMultiPlantHelper::isPartSpecialLTbbCapacity(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialLTFeatureCapacity")
return 1;
return 0;
}
// Returns 1 if part is a special feature Set LT capacity part, 0 otherwise
// If returns 1, also sets the part and pdf
int
LgFrMultiPlantHelper::isPartSpecialGTbbCapacity(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialGTFeatureCapacity")
return 1;
return 0;
}
// Returns 1 if part is a special Option dummy, 0 otherwise
// If returns 1, also sets the plannerTopLevelBuild, geo, bbCategory,
// and mfgOption part.
int
LgFrMultiPlantHelper::isPartSpecialOptionDummy(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory,
std::string & mfgOptionPart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
// bbCategory
mfgOptionPart = next(pdfSeparator_.c_str());
if (mfgOptionPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialOptionDummy")
return 1;
return 0;
}
// Returns 1 if Operation is a special Option dummy, 0 otherwise
// If returns 1, also sets the plannerTopLevelBuild, geo, bbCategory,
// and mfgOption part.
int
LgFrMultiPlantHelper::isOperationSpecialOptionDummy(
WitRun * const theWitRun,
const std::string & fullWitOperationName,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory,
std::string & mfgOptionPart)
{
witBoolean exists;
witGetOperationExists(theWitRun, fullWitOperationName.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitOperationName);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
// bbCategory
mfgOptionPart = next(pdfSeparator_.c_str());
if (mfgOptionPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialOptionDummy")
return 1;
return 0;
}
// Returns 1 if part is a special Option Ratio Supply, 0 otherwise
// If returns 1, also sets the plannerTopLevelBuild, geo, bbCategory,
// and mfgOption part.
int
LgFrMultiPlantHelper::isPartSpecialOptionRatioSupply(
WitRun * const theWitRun,
const std::string & fullWitPartname,
std::string & plannerTopLevelBuild,
std::string & geo,
std::string & bbCategory,
std::string & mfgOptionPart)
{
witBoolean exists;
witGetPartExists(theWitRun, fullWitPartname.c_str(), &exists);
if (exists == WitFALSE)
return 0;
SCETokenizer next(fullWitPartname);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty())
return 0;
// plannerTopLevelBuild
plannerTopLevelBuild = next(pdfSeparator_.c_str());
if (plannerTopLevelBuild.empty())
return 0;
// bbCategory
bbCategory = next(pdfSeparator_.c_str());
if (bbCategory.empty())
return 0;
// bbCategory
mfgOptionPart = next(pdfSeparator_.c_str());
if (mfgOptionPart.empty())
return 0;
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialOptionRatioSupply")
return 1;
return 0;
}
// Return 1 if a part is Buildable (ie, should be in the Build Schedule)
int
LgFrMultiPlantHelper::isPartBuildable(
WitRun * const theWitRun,
const std::string & fullWitPartname)
{
if (! this->isPartNormal(theWitRun, fullWitPartname))
return 0;
if (this->isPartNormalCapacity(theWitRun, fullWitPartname))
return 0;
if (this->isPartPcf(theWitRun, fullWitPartname))
return 0;
witBoolean exists;
witGetOperationExists(theWitRun, fullWitPartname.c_str(), &exists);
if (! exists)
return 0;
return 1;
}
int
LgFrMultiPlantHelper::isOperationValid(
WitRun * const theWitRun,
const std::string & pdfOperationName,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
const
{
witBoolean exists;
witGetOperationExists(theWitRun, pdfOperationName.c_str(), &exists);
if (exists == WitFALSE && messageLogic == MANDATORY) {
(*sceErrFacility_)("UnrecognizedOperationError",MclArgList() << pdfOperationName << fileName << (int)lineNo << dataLine);
// exits
}
if (exists == WitFALSE && messageLogic == OPTIONAL_WITH_MESSAGE) {
(*sceErrFacility_)("UnrecognizedOperationWarning",MclArgList() << pdfOperationName << fileName << (int)lineNo << dataLine);
return 0;
}
if (exists == WitFALSE)
return 0;
return 1;
}
// Return 1 if good, 0 if bad
int
LgFrMultiPlantHelper::isOperationValid(
WitRun * const theWitRun,
const std::string & operationName,
const std::string & pdf,
const std::string & filename,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
const
{
std::string pdfOperation = pdf + pdfSeparator_ + operationName;
witBoolean exists;
exists = this->isOperationValid(theWitRun, pdfOperation, filename, dataLine, lineNo, PURELY_OPTIONAL);
if (exists == WitFALSE && messageLogic == MANDATORY) {
(*sceErrFacility_)("UnrecognizedOperationPdfError",MclArgList()
<< operationName << pdf << filename << (int)lineNo << dataLine);
// exits
}
if (exists == WitFALSE && messageLogic == OPTIONAL_WITH_MESSAGE) {
(*sceErrFacility_)("UnrecognizedOperationPdfWarning",MclArgList()
<< operationName << pdf << filename << (int)lineNo << dataLine);
return 0;
}
if (exists == WitFALSE)
return 0;
return 1;
}
int
LgFrMultiPlantHelper::isPdfOperationUnique(
WitRun * const theWitRun,
const std::string & pdfOperationName,
const std::string & fileName,
const std::string & dataLine,
const long lineNo,
const int messageLogic)
const
{
witBoolean exists;
// check to see if a there is a pdf_part using the pdf_operation name.
witGetPartExists(theWitRun, pdfOperationName.c_str(), &exists);
if (exists == WitTRUE && messageLogic == MANDATORY) {
(*sceErrFacility_)("DuplicatePartPDFPairError",MclArgList() << pdfOperationName << fileName << (int)lineNo << dataLine);
// exits
}
if (exists == WitTRUE && messageLogic == OPTIONAL_WITH_MESSAGE) {
(*sceErrFacility_)("DuplicatePartPDFPairWarning",MclArgList() << pdfOperationName << fileName << (int)lineNo << dataLine);
return 0;
}
if (exists == WitTRUE)
return 0;
return 1;
}
// Return a geo_plannerPart_specialPureOptionBuildDemandName, given the
// fullWitName of a specialGeoPlannerDemand part
std::string
LgFrMultiPlantHelper::pureOptionBuildDemandName(
const std::string & fullWitPartName)
{
std::string plannerPart;
std::string geo;
SCETokenizer next(fullWitPartName);
// geo
geo = next(pdfSeparator_.c_str());
assert (! (geo.empty()));
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
assert (! (plannerPart.empty()));
return
geo
+ pdfSeparator_
+ plannerPart
+ pdfSeparator_
+ "specialPureOptionBuildDemandName";
}
// Returns 1 if demand is a specialPureOptionBuildDemand, 0 otherwise
// If returns 1, also sets the plannerPart and geo
int
LgFrMultiPlantHelper::isDemandSpecialPureOptionBuildDemand(
WitRun * const theWitRun,
const std::string & fullWitPartName,
const std::string & fullWitDemandName,
std::string & plannerPart,
std::string & geo)
{
witBoolean partExists;
witBoolean demandExists;
// check to see if the part exists
witGetPartExists(theWitRun, fullWitPartName.c_str(), &partExists);
if (partExists == WitFALSE)
return 0;
// check to see if the demand exists
int lenDemandList;
char ** demandList;
witGetPartDemands ( theWitRun, fullWitPartName.c_str(), &lenDemandList, &demandList);
// loop through the demand list searching for a match
// if you find one, set the boolean to True and break out of the loop
demandExists = WitFALSE;
int i = 0; // Pulled out of the for below by RW2STL
for (i=0; i<lenDemandList; i++){
if (fullWitDemandName == demandList[i]) {
demandExists = WitTRUE;
break;
}
}
// we're done with demandList -- get rid of it
for (i=0; i<lenDemandList; i++)
witFree(demandList[i]);
witFree(demandList);
if (demandExists == WitFALSE)
return 0;
// parse the fullWitDemandName to get the geo and plannerPart
SCETokenizer next(fullWitDemandName);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty()) {
return 0;
}
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty()){
return 0;
}
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialPureOptionBuildDemandName"){
return 1;
}
return 0;
}
// CUSTOMER_CHOICE_FEATURES
// Return a geo_plannerPart_specialCustChoiceDemandName, given the
// fullWitName of a specialGeoPlannerDemand part
std::string
LgFrMultiPlantHelper::custChoiceFeatureDemandName(
const std::string & fullWitPartName)
{
std::string plannerPart;
std::string geo;
SCETokenizer next(fullWitPartName);
// geo
geo = next(pdfSeparator_.c_str());
assert (! (geo.empty()));
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
assert (! (plannerPart.empty()));
return
geo
+ pdfSeparator_
+ plannerPart
+ pdfSeparator_
+ "specialCustChoiceFeatureDemand";
}
// Returns 1 if demand is a specialPureOptionBuildDemand, 0 otherwise
// If returns 1, also sets the plannerPart and geo
int
LgFrMultiPlantHelper::isDemandSpecialCustChoiceFeature(
WitRun * const theWitRun,
const std::string & fullWitPartName,
const std::string & fullWitDemandName,
std::string & plannerPart,
std::string & geo)
{
witBoolean partExists;
witBoolean demandExists;
// check to see if the part exists
witGetPartExists(theWitRun, fullWitPartName.c_str(), &partExists);
if (partExists == WitFALSE)
return 0;
// check to see if the demand exists
int lenDemandList;
char ** demandList;
witGetPartDemands ( theWitRun, fullWitPartName.c_str(), &lenDemandList, &demandList);
// loop through the demand list searching for a match
// if you find one, set the boolean to True and break out of the loop
demandExists = WitFALSE;
int i = 0; // Pulled out of the for below by RW2STL
for (i=0; i<lenDemandList; i++){
if (fullWitDemandName == demandList[i]) {
demandExists = WitTRUE;
break;
}
}
// we're done with demandList -- get rid of it
for (i=0; i<lenDemandList; i++)
witFree(demandList[i]);
witFree(demandList);
if (demandExists == WitFALSE)
return 0;
// parse the fullWitDemandName to get the geo and plannerPart
SCETokenizer next(fullWitDemandName);
// geo
geo = next(pdfSeparator_.c_str());
if (geo.empty()) {
return 0;
}
// plannerPart
plannerPart = next(pdfSeparator_.c_str());
if (plannerPart.empty()){
return 0;
}
std::string anythingSpecial = next(pdfSeparator_.c_str());
if (anythingSpecial == "specialCustChoiceFeatureDemand"){
return 1;
}
return 0;
}
// set/get the pdf-partname delimiter string
std::string
LgFrMultiPlantHelper::pdfSeparator()
const
{
return pdfSeparator_;
}
void
LgFrMultiPlantHelper::pdfSeparator(
const std::string & pdfSeparator)
{
pdfSeparator_ = pdfSeparator;
}
// set/get the default PDF string
std::string
LgFrMultiPlantHelper::defaultPdf()
const
{
return defaultPdf_;
}
void
LgFrMultiPlantHelper::defaultPdf(
const std::string & defaultPdf)
{
defaultPdf_ = defaultPdf;
}
// multi_attribute_demand
void
LgFrMultiPlantHelper::multiAttributeDemandSeparator(
const std::string & multiAttributeDemandSeparator)
{
multiAttributeDemandSeparator_ = multiAttributeDemandSeparator;
}
std::string
LgFrMultiPlantHelper::multiAttributeDemandSeparator()
const
{
return multiAttributeDemandSeparator_;
}
void
LgFrMultiPlantHelper::useMultiAttributeDemand(
const bool useMultiAttributeDemand)
{
useMultiAttributeDemand_ = useMultiAttributeDemand;
}
bool
LgFrMultiPlantHelper::useMultiAttributeDemand()
const
{
return useMultiAttributeDemand_;
}
void
LgFrMultiPlantHelper::useDemand2OrderINDP(
const bool useDemand2OrderINDP)
{
useDemand2OrderINDP_ = useDemand2OrderINDP;
}
bool
LgFrMultiPlantHelper::useDemand2OrderINDP()
const
{
return useDemand2OrderINDP_;
}
void
LgFrMultiPlantHelper::truncOffsetToEol(
const bool truncOffsetToEol)
{
truncOffsetToEol_ = truncOffsetToEol;
}
// set/get the default PDF string
bool
LgFrMultiPlantHelper::truncOffsetToEol()
const
{
return truncOffsetToEol_;
}
void
LgFrMultiPlantHelper::numDemandAttributes(
const int numDemandAttributes)
{
numDemandAttributes_ = numDemandAttributes;
}
int
LgFrMultiPlantHelper::numDemandAttributes()
const
{
return numDemandAttributes_;
}
// Get the PDF for a PDF_PART
std::string
LgFrMultiPlantHelper::pdf(const LgFrPart & part)
const
{
return this->pdf(part.name());
}
// Parse the string looking for two pieces, the PDF and
// the partname. If you only find one piece, then assume
// that this is a partname and that the PDF is the default.
std::string
LgFrMultiPlantHelper::pdf(const std::string & pdfPart)
const
{
SCETokenizer next(pdfPart);
std::string thePdf = next(pdfSeparator_.c_str());
assert (! thePdf.empty());
std::string thePartName = next(pdfSeparator_.c_str());
if (thePartName.empty())
return defaultPdf_;
return thePdf;
}
std::string
LgFrMultiPlantHelper::pdf(const char * pdfPart)
const
{
return this->pdf(std::string(pdfPart));
}
// Parse the string looking for two pieces, the PDF and
// the partname. If you only find one piece, then assume
// that this is THE partname`
std::string
LgFrMultiPlantHelper::partname(const std::string & pdfPart)
const
{
SCETokenizer next(pdfPart);
std::string thePdf = next(pdfSeparator_.c_str());
assert (! thePdf.empty());
std::string thePartName = next(pdfSeparator_.c_str());
if (thePartName.empty())
return thePdf;
return thePartName;
}
// Return just the operationName of a pdf_operationName.
// Parse the string looking for two pieces, the PDF and
// the operationName. If you only find one piece, then assume
// that this is THE operationName.
std::string
LgFrMultiPlantHelper::operationName(const std::string & pdfOperation)
const
{
return this->partname(pdfOperation);
}
// Are the parts equivalent, irrespective of the PDF?
bool
LgFrMultiPlantHelper::isPartnameEqual(const std::string & left, const std::string & right)
const
{
return (this->partname(left) == this->partname(right));
}
//
// returns 1 if the duplicate interplant record's usage rate is the same
// as the usage rate on the previous record (ie. the current
// usage rate on the interplant bom)
// 0 otherwise
int
LgFrMultiPlantHelper::isDuplicateInterplantRecordUsageRateValid(
WitRun * const theWitRun,
const std::string & sourcePdfPartName,
const std::string & interplantOperationName,
float duplicateRecordUsageRate )
{
int nBoms;
witGetOperationNBomEntries( theWitRun,
interplantOperationName.c_str(),
&nBoms );
assert ( nBoms == 1 );
float currentUsageRate;
witGetBomEntryUsageRate( theWitRun,
interplantOperationName.c_str(),
0,
¤tUsageRate );
// if usage rates are not equal, then return 0
if (( duplicateRecordUsageRate > (currentUsageRate + MULTIPLANTHELPER_FLT_EPS)) ||
( duplicateRecordUsageRate < (currentUsageRate - MULTIPLANTHELPER_FLT_EPS))) {
return (0);
}
// the usage rate are equal
return (1) ;
}
//
// returns 1 if the duplicate interplant record's effectivity
// dates do not overlap with the effectivity
// dates of interplant operation's existing bops
// 0 otherwise
int
LgFrMultiPlantHelper::isDuplicateInterplantRecordEffectivityDatesValid(
WitRun * const theWitRun,
const std::string & interplantOperationName,
int duplicateRecordStart,
int duplicateRecordEnd )
{
if ( duplicateRecordStart > duplicateRecordEnd )
return 0;
int nbBops;
witGetOperationNBopEntries( theWitRun,
interplantOperationName.c_str(),
&nbBops );
size_t b = 0; // Pulled out of the for below by RW2STL
for ( b=0; b<nbBops; b++) {
int currentBopStart;
int currentBopEnd;
witGetBopEntryEarliestPeriod( theWitRun,
interplantOperationName.c_str(),
b,
¤tBopStart);
witGetBopEntryLatestPeriod( theWitRun,
interplantOperationName.c_str(),
b,
¤tBopEnd);
// For now, if there's a bop in there with effectivity turned off,
// we have problems...
assert ( currentBopStart <= currentBopEnd );
// if they're not "disjoint", the record's invalid. Return 0.
if (!( ((duplicateRecordStart < currentBopStart) &&
(duplicateRecordEnd < currentBopStart)) // before
|| // or
((duplicateRecordStart > currentBopEnd) && // after
(duplicateRecordEnd > currentBopEnd))) )
return 0;
}
// none of the records overlapped. the record's valid. Return 1.
return 1;
}
//
// returns 1 if the duplicate interplant record's usage rate is the same
// as the usage rate on the previous record (ie. the current
// usage rate on the interplant bom)
// 0 otherwise
int
LgFrMultiPlantHelper::isDuplicateAlternatePartRecordUsageRateValid(
WitRun * const theWitRun,
const std::string & fullAltPartPdfName,
const std::string & alternatePartOperationName,
float duplicateRecordUsageRate )
{
int nBoms;
witGetOperationNBomEntries( theWitRun,
alternatePartOperationName.c_str(),
&nBoms );
assert ( nBoms == 1 );
float currentUsageRate;
witGetBomEntryUsageRate( theWitRun,
alternatePartOperationName.c_str(),
0,
¤tUsageRate );
// if usage rates are not equal, then return 0
if (( duplicateRecordUsageRate > (currentUsageRate + MULTIPLANTHELPER_FLT_EPS)) ||
( duplicateRecordUsageRate < (currentUsageRate - MULTIPLANTHELPER_FLT_EPS))) {
return (0);
}
// the usage rate are equal
return (1) ;
}
//
// returns 1 if the duplicate alternatePart record's effectivity
// dates do not overlap with the effectivity
// dates of alternatePart operation's existing bops
// 0 otherwise
int
LgFrMultiPlantHelper::isDuplicateAlternatePartRecordEffectivityDatesValid(
WitRun * const theWitRun,
const std::string & alternatePartOperationName,
int duplicateRecordStart,
int duplicateRecordEnd )
{
if ( duplicateRecordStart > duplicateRecordEnd )
return 0;
int nbBops;
witGetOperationNBopEntries( theWitRun,
alternatePartOperationName.c_str(),
&nbBops );
size_t b = 0; // Pulled out of the for below by RW2STL
for ( b=0; b<nbBops; b++) {
int currentBopStart;
int currentBopEnd;
witGetBopEntryEarliestPeriod( theWitRun,
alternatePartOperationName.c_str(),
b,
¤tBopStart);
witGetBopEntryLatestPeriod( theWitRun,
alternatePartOperationName.c_str(),
b,
¤tBopEnd);
// For now, if there's a bop in there with effectivity turned off,
// we have problems...
assert ( currentBopStart <= currentBopEnd );
// if they're not "disjoint", the record's invalid. Return 0.
if (!( ((duplicateRecordStart < currentBopStart) &&
(duplicateRecordEnd < currentBopStart)) // before
|| // or
((duplicateRecordStart > currentBopEnd) && // after
(duplicateRecordEnd > currentBopEnd))) )
return 0;
}
// none of the records overlapped. the record's valid. Return 1.
return 1;
}
// Return a copy in the heap
LgFrMultiPlantHelper*
LgFrMultiPlantHelper::clone()
const
{
return new LgFrMultiPlantHelper(*this);
}
// copy constructor
LgFrMultiPlantHelper::LgFrMultiPlantHelper(const LgFrMultiPlantHelper& source)
: pdfSeparator_(source.pdfSeparator_),
defaultPdf_(source.defaultPdf_),
useMultiAttributeDemand_(source.useMultiAttributeDemand_),
truncOffsetToEol_(source.truncOffsetToEol_),
numDemandAttributes_(source.numDemandAttributes_),
multiAttributeDemandSeparator_(source.multiAttributeDemandSeparator_),
useDemand2OrderINDP_(source.useDemand2OrderINDP_),
sceErrFacility_(source.sceErrFacility_)
{
// nothing to do
}
// assignment operator
LgFrMultiPlantHelper&
LgFrMultiPlantHelper::operator=(const LgFrMultiPlantHelper& rhs)
{
if (this != &rhs) { // Check for assignment to self
pdfSeparator_ = rhs.pdfSeparator_;
defaultPdf_ = rhs.defaultPdf_;
useMultiAttributeDemand_ = rhs.useMultiAttributeDemand_;
truncOffsetToEol_ = rhs.truncOffsetToEol_;
numDemandAttributes_ = rhs.numDemandAttributes_;
multiAttributeDemandSeparator_ = rhs.multiAttributeDemandSeparator_;
useDemand2OrderINDP_ = rhs.useDemand2OrderINDP_;
sceErrFacility_ = rhs.sceErrFacility_;
}
return *this;
}
// destructor
LgFrMultiPlantHelper::~LgFrMultiPlantHelper()
{
// nothing to do
}
#ifdef NDEBUG
#undef NDEBUG
#endif
// self-test
void
LgFrMultiPlantHelper::test()
{
LgFrMultiPlantHelper multiPlantHelper;
assert(multiPlantHelper.pdfSeparator() == "_ \t\n");
assert(multiPlantHelper.defaultPdf() == "WW");
std::string testPart1("POK_xx123");
std::string testPart2("FUJ_xx123");
std::string testPart3("xx123");
std::string testPart4("WW_yy123");
assert(multiPlantHelper.partname(testPart1) ==
multiPlantHelper.partname(testPart2));
assert(multiPlantHelper.isPartnameEqual(testPart1, testPart2));
assert(multiPlantHelper.isPartnameEqual(testPart1, testPart3));
assert(multiPlantHelper.isPartnameEqual(testPart1.c_str(), testPart3));
assert(multiPlantHelper.isPartnameEqual(testPart1.c_str(), testPart3.c_str()));
assert(multiPlantHelper.isPartnameEqual(testPart1, testPart3.c_str()));
assert(multiPlantHelper.pdf(testPart1) == "POK");
assert(multiPlantHelper.pdf(testPart3) == "WW");
assert(multiPlantHelper.pdf(testPart3.c_str()) == "WW");
}
#endif
|
Below is an extract from a C++ program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C++ code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C++ concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., memory management). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C++. It should be similar to a school exercise, a tutorial, or a C++ course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C++. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#include <iostream>
#include <string>
using namespace std;
class Shape {
private:
int x;
int y;
public:
Shape(int X = 0, int Y = 0)
:x(X), y(Y) {
cout << "Shape Constructor..." << endl;
}
void setCoord(int X, int Y) {
x = X;
y = Y;
}
void print() {
cout << "(" << x<<"," << y << ")";
}
};
class Circle :public Shape {
float radius;
public:
Circle(int X = 0, int Y = 0, float r = 0)
:Shape(X, Y), radius(r) {
cout << "Circle Constructor..." << endl;
}
void setRadius(float r) {
radius = r;
}
void print() {
Shape::print();
cout <<", "<<radius;
}
};
class ColoredCircle :public Circle {
string color;
public:
ColoredCircle(int X = 0, int Y = 0, float r = 0,string c="red")
:Circle(X, Y,r), color(c) {
cout << "ColoredCircle Constructor..." << endl;
}
void setColor(string c) {
color = c;
}
void print() {
Circle::print();
cout << ", " << color;
}
};
int main() {
Circle c1(1, 2, 5.0);
c1.setCoord(3, 2);
c1.setRadius(7);
c1.print();
cout << endl;
ColoredCircle cc(1, 2, 5.0,"blue");
cc.setCoord(3, 2);
cc.setRadius(7);
cc.setColor("yellow");
cc.print();
Shape shape;
shape.setCoord(1, 2);
shape.print();
cout << endl;
return 0;
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| cpp | 4 | #include <iostream>
#include <string>
using namespace std;
class Shape {
private:
int x;
int y;
public:
Shape(int X = 0, int Y = 0)
:x(X), y(Y) {
cout << "Shape Constructor..." << endl;
}
void setCoord(int X, int Y) {
x = X;
y = Y;
}
void print() {
cout << "(" << x<<"," << y << ")";
}
};
class Circle :public Shape {
float radius;
public:
Circle(int X = 0, int Y = 0, float r = 0)
:Shape(X, Y), radius(r) {
cout << "Circle Constructor..." << endl;
}
void setRadius(float r) {
radius = r;
}
void print() {
Shape::print();
cout <<", "<<radius;
}
};
class ColoredCircle :public Circle {
string color;
public:
ColoredCircle(int X = 0, int Y = 0, float r = 0,string c="red")
:Circle(X, Y,r), color(c) {
cout << "ColoredCircle Constructor..." << endl;
}
void setColor(string c) {
color = c;
}
void print() {
Circle::print();
cout << ", " << color;
}
};
int main() {
Circle c1(1, 2, 5.0);
c1.setCoord(3, 2);
c1.setRadius(7);
c1.print();
cout << endl;
ColoredCircle cc(1, 2, 5.0,"blue");
cc.setCoord(3, 2);
cc.setRadius(7);
cc.setColor("yellow");
cc.print();
Shape shape;
shape.setCoord(1, 2);
shape.print();
cout << endl;
return 0;
} |
Below is an extract from a Ruby program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Ruby code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Ruby concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., metaprogramming, blocks). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Ruby. It should be similar to a school exercise, a tutorial, or a Ruby course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Ruby. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
# Assigning value of 100 to cars
cars = 100
# Defining how many people fit in each car with a floating point number
space_in_car = 4.0
# Assigning the value of 30 to drivers
drivers = 30
# Assigning the value of 90 to passengers
passengers = 90
# Calculating the value for cars not being driven
cars_not_driven = cars - drivers
# Setting the value of cars driven to the same that drivers has
cars_driven = drivers
# Calculating the carpool capacity using the space_in_car and cars_driven already established
carpool_capacity = cars_driven * space_in_car
# Calculating the average of passengers for the cars being driven
average_passengers_per_car = passengers / cars_driven
puts "There are #{cars} cars available."
puts "There are only #{drivers} drivers available."
puts "There will be #{cars_not_driven} empty cars today."
puts "We can transport #{carpool_capacity} people today."
puts "We have #{passengers} passengers to carpool today."
puts "We need to put about #{average_passengers_per_car} in each car."
# Extra Credit: It happened because the writer did not defined the carpool_capacity variable.
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| ruby | 4 | # Assigning value of 100 to cars
cars = 100
# Defining how many people fit in each car with a floating point number
space_in_car = 4.0
# Assigning the value of 30 to drivers
drivers = 30
# Assigning the value of 90 to passengers
passengers = 90
# Calculating the value for cars not being driven
cars_not_driven = cars - drivers
# Setting the value of cars driven to the same that drivers has
cars_driven = drivers
# Calculating the carpool capacity using the space_in_car and cars_driven already established
carpool_capacity = cars_driven * space_in_car
# Calculating the average of passengers for the cars being driven
average_passengers_per_car = passengers / cars_driven
puts "There are #{cars} cars available."
puts "There are only #{drivers} drivers available."
puts "There will be #{cars_not_driven} empty cars today."
puts "We can transport #{carpool_capacity} people today."
puts "We have #{passengers} passengers to carpool today."
puts "We need to put about #{average_passengers_per_car} in each car."
# Extra Credit: It happened because the writer did not defined the carpool_capacity variable. |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import React from 'react';
const Status = (props) => {
const employees = props.selectedEmployees;
let totalSalary = 0;
let totalEmployees = [];
for (const employee of employees) {
totalSalary += employee.salary;
}
totalEmployees = employees.map(employee => <div key={employee.id} className="mb-1 text-center text-white rounded bg-info">
<div className="p-2 row">
<div className="col-md-2 ">
<img src={employee.img} className="rounded-circle" style={{ "height": "40px", "width": "40px" }} alt="" />
</div>
<div className="col-md-10">
<h6> {employee.name} <button type="button" onClick={() => props.handleRemoveEmployee(employee)} id="btn-confirm" className="px-3 btn btn-danger btn-sm">
<i className="fas fa-times"></i>
</button> </h6>
</div>
</div>
</div>)
return (
<div className="card">
<h2 className="mt-2 text-center">Employee Status</h2>
<div className="card-body">
<div className="card-text">
<h6 className='p-2 text-warning'>Total Amount of Hiring Employee: ${totalSalary}</h6>
</div>
<h5 className="p-2 text-center text-white card-title bg-dark ">Hired Employee List</h5>
{totalEmployees}
</div>
</div>
);
};
export default Status;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import React from 'react';
const Status = (props) => {
const employees = props.selectedEmployees;
let totalSalary = 0;
let totalEmployees = [];
for (const employee of employees) {
totalSalary += employee.salary;
}
totalEmployees = employees.map(employee => <div key={employee.id} className="mb-1 text-center text-white rounded bg-info">
<div className="p-2 row">
<div className="col-md-2 ">
<img src={employee.img} className="rounded-circle" style={{ "height": "40px", "width": "40px" }} alt="" />
</div>
<div className="col-md-10">
<h6> {employee.name} <button type="button" onClick={() => props.handleRemoveEmployee(employee)} id="btn-confirm" className="px-3 btn btn-danger btn-sm">
<i className="fas fa-times"></i>
</button> </h6>
</div>
</div>
</div>)
return (
<div className="card">
<h2 className="mt-2 text-center">Employee Status</h2>
<div className="card-body">
<div className="card-text">
<h6 className='p-2 text-warning'>Total Amount of Hiring Employee: ${totalSalary}</h6>
</div>
<h5 className="p-2 text-center text-white card-title bg-dark ">Hired Employee List</h5>
{totalEmployees}
</div>
</div>
);
};
export default Status; |
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# LIHAlert
#####LIHAlert provides animated banners for iOS which is written using the apple's newest programming language Swift 2.0.
[](https://travis-ci.org/<NAME>/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
### Usage
Import the module using
```Swift
import LIHAlert
```
To run the example project, clone the repo, and run `pod install` from the Example directory first.
####1. Predefined Banners
* Text banner
* Text with an ActivityIndicator
* Text with an icon
* Text with a button
* Text with two buttons
* Custom view banner
LIHAlert contains some predefined alerts for each Alert type. You can use following code snippets to use them.
#####1. Text Banner
<img src="http://3.bp.blogspot.com/-LLVpn6KrnNg/ViiaKmCHIqI/AAAAAAAACsw/13dVIUMG7E0/s300/TextBanner.gif" />
```Swift
var textAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.textAlert = LIHAlertManager.getTextAlert("Sample Message")
self.textAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
self.textAlert?.show(nil, hidden: nil)
}
```
Call showBanner() function to show the banner
To customize the banner,
```Swift
self.textAlert = LIHAlertManager.getTextAlert("Sample Message")
self.textAlert?.alertColor = UIColor.yellowColor()
textAlert.contentText = message
textAlert.alertColor = UIColor(red: 102.0/255.0, green: 197.0/255.0, blue: 241.0/255.0, alpha: 1.0)
textAlert.alertHeight = 50.0
textAlert.alertAlpha = 1.0
textAlert.autoCloseEnabled=true
textAlert.contentTextColor = UIColor.whiteColor()
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 4 | # LIHAlert
#####LIHAlert provides animated banners for iOS which is written using the apple's newest programming language Swift 2.0.
[](https://travis-ci.org/<NAME>/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
[](http://cocoapods.org/pods/LIHAlert)
### Usage
Import the module using
```Swift
import LIHAlert
```
To run the example project, clone the repo, and run `pod install` from the Example directory first.
####1. Predefined Banners
* Text banner
* Text with an ActivityIndicator
* Text with an icon
* Text with a button
* Text with two buttons
* Custom view banner
LIHAlert contains some predefined alerts for each Alert type. You can use following code snippets to use them.
#####1. Text Banner
<img src="http://3.bp.blogspot.com/-LLVpn6KrnNg/ViiaKmCHIqI/AAAAAAAACsw/13dVIUMG7E0/s300/TextBanner.gif" />
```Swift
var textAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.textAlert = LIHAlertManager.getTextAlert("Sample Message")
self.textAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
self.textAlert?.show(nil, hidden: nil)
}
```
Call showBanner() function to show the banner
To customize the banner,
```Swift
self.textAlert = LIHAlertManager.getTextAlert("Sample Message")
self.textAlert?.alertColor = UIColor.yellowColor()
textAlert.contentText = message
textAlert.alertColor = UIColor(red: 102.0/255.0, green: 197.0/255.0, blue: 241.0/255.0, alpha: 1.0)
textAlert.alertHeight = 50.0
textAlert.alertAlpha = 1.0
textAlert.autoCloseEnabled=true
textAlert.contentTextColor = UIColor.whiteColor()
textAlert.hasNavigationBar = true
textAlert.paddingTop = 0.0
textAlert.animationDuration = 0.35
textAlert.autoCloseTimeInterval = 1.5
self.textAlert?.initAlert(self.view)
```
#####2. Banner with a text and image
<img src="http://2.bp.blogspot.com/-pMF5l-2VR0c/ViiaJ8bohOI/AAAAAAAACss/qFciyfThVUg/s300/Success.gif" />
```Swift
var successAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.successAlert = LIHAlertManager.getSuccessAlert("Successfully subscribed")
self.successAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
self.successAlert?.show(nil, hidden: nil)
}
```
To change the icon,
```Swift
successAlert?.icon = UIImage(named:"imageName")
```
#####4. Loading Alert
This is a banner with a text and an activity indicator. This is not an auto close banner. You have to hide it when the process is finished.
<img src="http://3.bp.blogspot.com/-ASkTzpFIuSU/ViiaK2_mSYI/AAAAAAAACs8/6stjXecZWqI/s300/TextWithLoading.gif" />
```Swift
var processingAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.processingAlert = LIHAlertManager.getProcessingAlert("Fetching data...")
self.processingAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
self.processingAlert?.show(nil, hidden: nil)
}
override hideBanner(sender: AnyObject) {
self.processingAlert?.hide(nil)
}
```
Call showBanner() function to show the banner and hideBanner() to hide the banner.
To change the activity indicator style,
```Swift
processingAlert?.activityIndicatorStyle = UIActivityIndicatorViewStyle.WhiteLarge
```
#####5. Text with a button Alert
This alert contains a button along with a text. More suitable for notifying important messages to user.
<img src="http://2.bp.blogspot.com/-lrD_IGv93yE/ViiaKyqoRVI/AAAAAAAACs4/ggqDlP9E-YY/s300/TextWithButton.gif" />
```Swift
var textWithButtonAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.textWithButtonAlert = LIHAlertManager.getTextWithButtonAlert("You have successfully subscribed for the monthly newsletter", buttonText: "Dismiss")
self.textWithButtonAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
textWithButtonAlert?.show(nil, hidden: nil)
}
```
Call showBanner() function to show the banner.
Implement your view controller from LIHAlertDelegate.
```Swift
class ViewController: LIHAlertDelegate {
func buttonPressed(button: UIButton) {
print(“You have pressed the button”)
self.textWithButtonAlert?.hideAlert(nil)
}
}
```
#####6. Text with two buttons Alert
This alert contains two buttons along with a text.
<img src="http://3.bp.blogspot.com/-1pXYpVNoNz0/ViiaLcHSqnI/AAAAAAAACtI/NQjV1Pe9ACs/s300/TextWithTwoButtons.gif" />
```Swift
var textWithTwoButtonsAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
self.textWithTwoButtonsAlert = LIHAlertManager.getTextWithTwoButtonsAlert("Do you want to subscribe for the monthly newsletter?", buttonOneText: "Subscribe", buttonTwoText: "Cancel")
self.textWithTwoButtonsAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
textWithTwoButtonsAlert?.show(nil, hidden: nil)
}
```
Call showBanner() function to show the banner.
Implement your view controller from LIHAlertDelegate.
```Swift
class ViewController: LIHAlertDelegate {
func buttonOnePressed(button: UIButton) {
self.textWithTwoButtonsAlert?.hideAlert({ () -> () in
self.successAlert?.show(nil, hidden: nil)
})
}
func buttonTwoPressed(button: UIButton) {
self.textWithTwoButtonsAlert?.hideAlert(nil)
}
}
```
#####7. Custom View Alert
You can specify any view to act as the banner.
<img src="http://4.bp.blogspot.com/-lHReuTyaJ8A/ViiaJyAiEfI/AAAAAAAACso/Q9A-X3MNcTo/s300/CustomView.gif" />
```Swift
var customViewAlert: LIHAlert?
override func viewDidLoad() {
super.viewDidLoad()
//In this case I am using an ImageView as the banner
let customView = UIImageView(frame: CGRectMake(0.0, 64.0, 100, 50))
customView.image = UIImage(named: "customViewImage")
self.customViewAlert = LIHAlertManager.getCustomViewAlert(customView)
self.customViewAlert?.initAlert(self.view)
}
func showBanner(sender: AnyObject) {
self.customViewAlert?.show(nil, hidden: nil)
}
```
####2. Create a banner
```Swift
let alertTextAlert: LIHAlert = LIHAlert()
alertTextAlert.alertType = LIHAlertType.Text
alertTextAlert.contentText = message
alertTextAlert.alertColor = UIColor(red: 102.0/255.0, green: 197.0/255.0, blue: 241.0/255.0, alpha: 1.0)
alertTextAlert.alertHeight = 50.0
alertTextAlert.alertAlpha = 1.0
alertTextAlert.autoCloseEnabled=true
alertTextAlert.contentTextColor = UIColor.whiteColor()
alertTextAlert.hasNavigationBar = true
alertTextAlert.paddingTop = 0.0
alertTextAlert.animationDuration = 0.35
alertTextAlert.autoCloseTimeInterval = 1.5
```
#####LIHALertType
```Swift
enum LIHAlertType {
case Custom, Text, TextWithLoading, TextWithIcon, TextWithButton, TextWithTwoButtons
}
```
### Use the completion callbacks
```Swift
//when showing an auto hiding banner
lihAlert?.show({ () -> () in
//alert showed
}, hidden: { () -> () in
//alert hidden
})
//when hiding a banner
lihAlert?.hideAlert({ () -> () in
//Banner hidden
})
```
### Known Issues
##### 1. Top margin
In some projects the alert may appear with a margin on top. Hopefully this will be fixed in the next release. Until then use the following solution.
###### Solution
Even the navigation bar is there, set it to false.
```Swift
alert.hasNavigationBar = false
```
###Demo Project
The LIHAlert workspace contains a demo project, also used for development.
### Requirements
Xcode 7+
### Installation
LIHAlert is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:
```ruby
pod "LIHAlert"
```
or
Copy the LIHAlert folder into your project.
### Author
<NAME>, <EMAIL>
### License
LIHAlert is available under the MIT license. See the LICENSE file for more info.
|
Below is an extract from a Swift program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Swift code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Swift concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., protocols, extensions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Swift. It should be similar to a school exercise, a tutorial, or a Swift course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Swift. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// ViewController.swift
// tippy_December2016
//
// Created by ewood on 3/3/17.
// Copyright © 2017 ewood. All rights reserved.
//
import UIKit
class ViewController: UIViewController, passTipThemeDelegate
{
let settingsVC = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "SecondVC") as! SettingsViewController
let locale_identifiers = ["en_UK", "en_US", "es_US", "fr_FR", "it_IT", "zh_Hans_CN", "zh_Hans_HK"]
var locale_dict: [String: Locale ] = ["en_UK": Locale.current, "en_US": Locale.current, "es_US": Locale.current, "fr_FR": Locale.current, "it_IT": Locale.current, "zh_Hans_CN": Locale.current, "zh_Hans_HK": Locale.current ]
var symbols_dict: [String: String? ] = ["en_UK": Locale.current.currencySymbol, "en_US": Locale.current.currencySymbol, "es_US": Locale.current.currencySymbol, "fr_FR": Locale.current.currencySymbol, "it_IT": Locale.current.currencySymbol, "zh_Hans_CN": Locale.current.currencySymbol, "zh_Hans_HK": Locale.current.currencySymbol ]
var Saved_Default_tip: String?
var app_locale: Locale = Locale.current
// var app_currency_symbol: String =
// app_locale.object(forKey: "currencySymbol")
let UD_billAmt: String = "UD_bill_Amount"
let UD_saveDate: String = "UD_save_Date"
let UD_tipPCent: String = "UD_tip_PC_save"
let UD_appLocale: String = "UD_Locale_save"
@IBOutlet weak var tipControl: UISegmentedControl!
@IBOutlet weak var imageView1: UIImageView!
@IBOutlet weak var billField1: UITextField!
@IBOutlet weak var tipLabel: UILabel!
@IBOutlet weak var totalLabel: UILabel!
@IBOutlet weak var SavedTipDef_Label: UILabel!
@IBOutlet weak var SavedLocale_Label: UILabel!
var retn_theme2set_B: Bool = false
// @IBAction func billResetButton(_ sender: Any)
// {
// let userDefaults = Foundation.UserDefaults.standard
// userDefaults.set("", forKey:UD_billAmt)
// billFie
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| swift | 2 | //
// ViewController.swift
// tippy_December2016
//
// Created by ewood on 3/3/17.
// Copyright © 2017 ewood. All rights reserved.
//
import UIKit
class ViewController: UIViewController, passTipThemeDelegate
{
let settingsVC = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "SecondVC") as! SettingsViewController
let locale_identifiers = ["en_UK", "en_US", "es_US", "fr_FR", "it_IT", "zh_Hans_CN", "zh_Hans_HK"]
var locale_dict: [String: Locale ] = ["en_UK": Locale.current, "en_US": Locale.current, "es_US": Locale.current, "fr_FR": Locale.current, "it_IT": Locale.current, "zh_Hans_CN": Locale.current, "zh_Hans_HK": Locale.current ]
var symbols_dict: [String: String? ] = ["en_UK": Locale.current.currencySymbol, "en_US": Locale.current.currencySymbol, "es_US": Locale.current.currencySymbol, "fr_FR": Locale.current.currencySymbol, "it_IT": Locale.current.currencySymbol, "zh_Hans_CN": Locale.current.currencySymbol, "zh_Hans_HK": Locale.current.currencySymbol ]
var Saved_Default_tip: String?
var app_locale: Locale = Locale.current
// var app_currency_symbol: String =
// app_locale.object(forKey: "currencySymbol")
let UD_billAmt: String = "UD_bill_Amount"
let UD_saveDate: String = "UD_save_Date"
let UD_tipPCent: String = "UD_tip_PC_save"
let UD_appLocale: String = "UD_Locale_save"
@IBOutlet weak var tipControl: UISegmentedControl!
@IBOutlet weak var imageView1: UIImageView!
@IBOutlet weak var billField1: UITextField!
@IBOutlet weak var tipLabel: UILabel!
@IBOutlet weak var totalLabel: UILabel!
@IBOutlet weak var SavedTipDef_Label: UILabel!
@IBOutlet weak var SavedLocale_Label: UILabel!
var retn_theme2set_B: Bool = false
// @IBAction func billResetButton(_ sender: Any)
// {
// let userDefaults = Foundation.UserDefaults.standard
// userDefaults.set("", forKey:UD_billAmt)
// billField1.text = ""
// view.endEditing(false)
// }
@IBAction func ToSettings(_ sender: UIButton) {
self.present(settingsVC, animated: true, completion: nil)
}
override func viewDidLoad()
{
super.viewDidLoad()
settingsVC.tipThemeDelegate = self
for (_, e) in (locale_identifiers.enumerated()) {
let locale: Locale = Locale.init(identifier: e)
locale_dict[e] = locale
let currencySymbol = locale.currencySymbol
symbols_dict[e] = currencySymbol
print ("VC_VDL01:locale=[", e, "] currency_symbol=", currencySymbol as Any)
}
let bf_fr: Bool = billField1.becomeFirstResponder(
)
if (bf_fr) {
print("mainVC22: BF 1 resp ok")
} else {
print("mainVC24: BF 1 resp nogo")
}
// self.onTap(billField)
}
override func viewWillAppear(_ animated: Bool)
{
let now = Foundation.Date()
printLog(log: "M_viewWillAppear_10" as AnyObject)
let userDefaults = Foundation.UserDefaults.standard
var saveDate: Date! = nil
let formatter: DateFormatter = DateFormatter.init()
if (userDefaults.value(forKey:UD_saveDate) != nil)
{
saveDate = userDefaults.value(forKey: UD_saveDate) as! Date
let expireTime: Date =
saveDate.addingTimeInterval(600)
let saveDateC = formatter.string(from: saveDate)
let expireTimeC = formatter.string(from: expireTime)
print("ViewWillAppear_20: Saved Date()=", (saveDate), " now= ", (now), " ExpireTime= ", (expireTime))
let notExpire: Bool = expireTime > now
if (notExpire) {
print("M_VWAppear_22 not expired")
} else {
print("M_VWAppear_24 yes expired")
userDefaults.set("", forKey:UD_billAmt)
billField1.text = ""
}
}
SavedLocale_Label.text = ""
if (userDefaults.value(forKey: UD_appLocale) != nil)
{
let saved_locale: String = userDefaults.value(forKey: UD_appLocale) as! String
for locale_str in locale_identifiers
{
if (saved_locale == locale_str) {
app_locale = locale_dict[locale_str]!
SavedLocale_Label.text = saved_locale
}
}
print("VC1_WWA_050 App_saved_Locale_str=[", saved_locale)
} else {
print("VC1_WWA_051 No saved Locale found")
}
var billAmt: String = "";
if (userDefaults.value(forKey: UD_billAmt) != nil)
{
billAmt = userDefaults.value(forKey:UD_billAmt) as! String
print("ViewWillAppear_60 saved billAmt:", (billAmt) )
billField1.text = billAmt
}
// let tip_from_Settings: String = ""
SavedTipDef_Label.text = ""
let tip_Formatter: NumberFormatter = NumberFormatter()
tip_Formatter.usesGroupingSeparator = true
tip_Formatter.numberStyle = .currency
tip_Formatter.locale = app_locale
if (userDefaults.value(forKey: UD_tipPCent) != nil)
{
let tip_settings: String = userDefaults.value(forKey: UD_tipPCent) as! String
let tipFromStr1:NSNumber = Double(tip_settings) as NSNumber? ?? 0.0
let temp1:String = tip_Formatter.string(from: tipFromStr1 as NSNumber)!
print("M_WWA_Debug065 [", temp1, "]")
SavedTipDef_Label.text = tip_settings
}
switch (SavedTipDef_Label.text)
{
case "10"?:
tipControl.selectedSegmentIndex = 0
case "12.5"?:
tipControl.selectedSegmentIndex = 1
case "15"?:
tipControl.selectedSegmentIndex = 2
case "17.5"?:
tipControl.selectedSegmentIndex = 3
case "20"?:
tipControl.selectedSegmentIndex = 4
case "22.5"?:
tipControl.selectedSegmentIndex = 5
case "25"?:
tipControl.selectedSegmentIndex = 6
default: print (
"Error in View_C Seg_Control_75[", SavedTipDef_Label.text as Any, "]")
}
var secsElapse: Int = 0
if (saveDate != nil) {
secsElapse = Int(now.timeIntervalSince(saveDate))
print("SettingsCntlr VVA_60:", saveDate, now, secsElapse)
}
// let bf_fr: Bool = billField1.becomeFirstResponder(
// )
// if (bf_fr) {
// print("mainVC26: BF 1 resp ok")
// } else {
// print("mainVC28: BF 1 resp nogo")
// }
if (retn_theme2set_B)
{
self.view.backgroundColor = UIColor.lightGray
billField1.backgroundColor = UIColor.lightGray
billField1.textColor = UIColor.yellow
tipLabel.backgroundColor = UIColor.lightGray
tipLabel.textColor = UIColor.yellow
totalLabel.backgroundColor = UIColor.lightGray
totalLabel.textColor = UIColor.yellow
tipControl.backgroundColor = UIColor.lightGray
SavedTipDef_Label.backgroundColor = UIColor.lightGray
SavedTipDef_Label.textColor = UIColor.yellow
SavedLocale_Label.backgroundColor = UIColor.lightGray
SavedLocale_Label.textColor = UIColor.yellow
} else {
self.view.backgroundColor = UIColor.white
billField1.backgroundColor = UIColor.white
billField1.textColor = UIColor.black
tipLabel.backgroundColor = UIColor.white
tipLabel.textColor = UIColor.black
totalLabel.backgroundColor = UIColor.white
totalLabel.textColor = UIColor.black
tipControl.backgroundColor = UIColor.white
SavedTipDef_Label.backgroundColor = UIColor.white
SavedTipDef_Label.textColor = UIColor.black
SavedLocale_Label.backgroundColor = UIColor.white
SavedLocale_Label.textColor = UIColor.black
}
// imageView1.animatew
imageView1.startAnimating()
}
// @IBAction func SettingsButtonPressed(_ sender: Any) {
// dismiss(animated: true, completion: nil)
// localeDataDelegate?.passlocateData(locale: locale_identifiers)
// }
@IBAction func seg_value_Changed(_ sender: Any) {
let tipPercentages =
[ 0.1, 0.125, 0.15, 0.175,0.2, 0.225, 0.25 ]
let bill = Double(billField1.text!) ?? 0
let tip = bill * (tipPercentages[tipControl.selectedSegmentIndex]);
let total = bill + tip
let currencyFormatter = NumberFormatter()
currencyFormatter.usesGroupingSeparator = true
currencyFormatter.numberStyle =
.currency
currencyFormatter.locale = app_locale
var tipStr:String = ""
let tip_fmt_D: NSNumber = Double(tip) as NSNumber? ?? 0.0
tipStr = currencyFormatter.string(from: tip_fmt_D as NSNumber)!
tipLabel.text = tipStr
// String(format: "$%.2f", tipStr)
var totalStr:String = ""
let tot_fmt_D: NSNumber = Double(total) as NSNumber? ?? 0.0
totalStr = currencyFormatter.string(from: tot_fmt_D as NSNumber)!
totalLabel.text = totalStr
// String(format: "$%.2f", totalStr)
print("VC_SVC_90 tipstr", tipStr, " totalStr=", totalStr)
}
@IBAction func save_tip_Amount(_ sender: Any)
{
let userDefaults = Foundation.UserDefaults.standard
userDefaults.set(billField1.text, forKey:UD_billAmt)
let now: Date = Foundation.Date()
userDefaults.set(now, forKey:UD_saveDate)
}
@IBAction func calculateTip(_ sender: Any)
{
let now: Date = Foundation.Date()
let userDefaults = Foundation.UserDefaults.standard
userDefaults.set(billField1.text, forKey:"billAmount")
userDefaults.set(now, forKey:UD_saveDate)
let tipPercentages =
[ 0.1, 0.125, 0.15, 0.175,0.2, 0.225, 0.25 ]
let bill = Double(billField1.text!) ?? 0
let tip = bill * (tipPercentages[tipControl.selectedSegmentIndex]);
let total = bill + tip
tipLabel.text = String(format: "$%.2f", tip)
totalLabel.text = String(format: "$%.2f", total)
}
@IBAction func onTap(_ sender: Any) {
view.endEditing(true)
}
func printLog(log: AnyObject?) {
let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSS"
print(formatter.string(from: NSDate() as Date))
if log == nil
{ print("nil") } else
{ print(log!) }
}
func passTipTheme(lightDark: Bool) {
retn_theme2set_B = lightDark
print("VC2=>VC1_return_TipTheme=[", retn_theme2set_B, "]")
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
// protocol passLocaleDataDelegate {
// func passlocateData(locale: [String])
// }
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class CharacterCustomizer : MonoBehaviour
{
public GameObject[] upperwear, lowerwear, headwear;
public int current_upperwear, current_lowerwear, current_headwear;
public PlayerNetworkManager PNManager;
public ColorPicker skinColor;//
public ColorPicker topColor;
public ColorPicker bottomColor;
// Start is called before the first frame update
void Start()
{
Color skin;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("SkinColor"),"FFFFFF"), out skin);
Color top;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("TopColor"),"FFFFFF"), out top);
Color bottom;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("BottomColor"),"FFFFFF"), out bottom);
// skinColor.Create(skin,null,null,null);
// topColor.Create(top,null,null,null);
// bottomColor.Create(bottom,null,null,null);
}
// Update is called once per frame
void Update()
{
// for (int i = 0; i < upperwear.Length; i++)
// {
// if(i == current_upperwear)
// upperwear[i].SetActive(true);
// else
// upperwear[i].SetActive(false);
// }
// for (int i = 0; i < lowerwear.Length; i++)
// {
// if(i == current_lowerwear)
// lowerwear[i].SetActive(true);
// else
// lowerwear[i].SetActive(false);
// }
// for (int i = 0; i < headwear.Length; i++)
// {
// if(i == current_headwear)
// headwear[i].SetActive(true);
// else
// headwear[i].SetActive(false);
// }
}
public void SetSkinColor()
{
PlayerPrefs.SetString("SkinColor",ColorUtility.T
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 1 | using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class CharacterCustomizer : MonoBehaviour
{
public GameObject[] upperwear, lowerwear, headwear;
public int current_upperwear, current_lowerwear, current_headwear;
public PlayerNetworkManager PNManager;
public ColorPicker skinColor;//
public ColorPicker topColor;
public ColorPicker bottomColor;
// Start is called before the first frame update
void Start()
{
Color skin;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("SkinColor"),"FFFFFF"), out skin);
Color top;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("TopColor"),"FFFFFF"), out top);
Color bottom;
ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString(PlayerPrefs.GetString("BottomColor"),"FFFFFF"), out bottom);
// skinColor.Create(skin,null,null,null);
// topColor.Create(top,null,null,null);
// bottomColor.Create(bottom,null,null,null);
}
// Update is called once per frame
void Update()
{
// for (int i = 0; i < upperwear.Length; i++)
// {
// if(i == current_upperwear)
// upperwear[i].SetActive(true);
// else
// upperwear[i].SetActive(false);
// }
// for (int i = 0; i < lowerwear.Length; i++)
// {
// if(i == current_lowerwear)
// lowerwear[i].SetActive(true);
// else
// lowerwear[i].SetActive(false);
// }
// for (int i = 0; i < headwear.Length; i++)
// {
// if(i == current_headwear)
// headwear[i].SetActive(true);
// else
// headwear[i].SetActive(false);
// }
}
public void SetSkinColor()
{
PlayerPrefs.SetString("SkinColor",ColorUtility.ToHtmlStringRGB(skinColor.colorComponent.color));//
PNManager.AssignPlayerCustomisationData();
}
public void SetTopColor()
{
PlayerPrefs.SetString("TopColor",ColorUtility.ToHtmlStringRGB(topColor.colorComponent.color));//
PNManager.AssignPlayerCustomisationData();
}
public void SetBottomColor()
{
PlayerPrefs.SetString("BottomColor",ColorUtility.ToHtmlStringRGB(bottomColor.colorComponent.color));//
PNManager.AssignPlayerCustomisationData();
}
public void SetUpperWear(int index)
{
PlayerPrefs.SetInt("UpperWear",index);
current_upperwear = index;
PNManager.AssignPlayerCustomisationData();
}
public void SetLowerWear(int index)
{
PlayerPrefs.SetInt("LowerWear",index);
current_lowerwear = index;
PNManager.AssignPlayerCustomisationData();
}
public void SetHeadWear(int index)
{
PlayerPrefs.SetInt("HeadWear",index);
current_headwear = index;
PNManager.AssignPlayerCustomisationData();
}
public void MainMenu()
{
SceneManager.LoadScene(0);
}
}
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use super::collision::*;
use super::std_extended::*;
use crate::world_update::GameObj;
use crate::world_update::GameObjBlueprint;
use ordered_float::OrderedFloat;
use crate::world_update::FrameCount;
use ggez::graphics::Drawable;
pub enum Bounds<'a> {
Rect { size : &'a Size },
Circle { v : &'a CircleBounds },
}
// entities on different layers do not collide
#[derive(PartialEq, Eq, Debug)]
pub enum Tile { Floor = 0, Middle = 1, Sky = 2 }
#[derive(Debug)]
pub struct RectTile { pub tile : Tile, pub bounds : RectBounds }
#[derive(Debug)]
pub struct World { pub size : Size, pub objects : Vec<GameObj>, pub time : u64 }
pub fn generate_world(size : Size, wanderers : i32) -> World {
let mut world = World { size, objects: vec![], time : 0 };
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::TREE, None);
add_objects(&mut world, Tile::Floor, &GameObjBlueprint::HARE, Some(100));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::WOLF, Some(10));
add_objects(&mut world, Tile::Floor, &GameObjBlueprint::GRASS, Some(1000));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::WANDERER, Some(wanderers));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::PLAYER, Some(1));
world
}
fn add_object(size : &Size, objects : &mut Vec<GameObj>, blueprint : &'static GameObjBlueprint, time : FrameCount) -> bool {
let bounds = gen_circle_bounds(size, None, objects, blueprint);
if bounds.is_some() { objects.push(GameObj::from(&blueprint, bounds.unwrap(), time)); true } else { false }
}
pub fn add_objects(w : &mut World, tile : Tile, blueprint : &'static GameObjBlueprint, count : Option<i32>) {
let objects = &mut w.objects;
let time = w.time;
if count.is_none() {
loop { if !add_object(&w.size, objects, blueprint, time) { break } }
} else {
for _ in 0..count.unwrap() { add_object(&w.size, objects, blueprint, time); }
}
}
//maybe support circular bounds too
pub fn gen_circle_bounds(
size : &Size,
center_bounds : Option<&CircleBounds>,
objects
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 3 | use super::collision::*;
use super::std_extended::*;
use crate::world_update::GameObj;
use crate::world_update::GameObjBlueprint;
use ordered_float::OrderedFloat;
use crate::world_update::FrameCount;
use ggez::graphics::Drawable;
pub enum Bounds<'a> {
Rect { size : &'a Size },
Circle { v : &'a CircleBounds },
}
// entities on different layers do not collide
#[derive(PartialEq, Eq, Debug)]
pub enum Tile { Floor = 0, Middle = 1, Sky = 2 }
#[derive(Debug)]
pub struct RectTile { pub tile : Tile, pub bounds : RectBounds }
#[derive(Debug)]
pub struct World { pub size : Size, pub objects : Vec<GameObj>, pub time : u64 }
pub fn generate_world(size : Size, wanderers : i32) -> World {
let mut world = World { size, objects: vec![], time : 0 };
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::TREE, None);
add_objects(&mut world, Tile::Floor, &GameObjBlueprint::HARE, Some(100));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::WOLF, Some(10));
add_objects(&mut world, Tile::Floor, &GameObjBlueprint::GRASS, Some(1000));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::WANDERER, Some(wanderers));
add_objects(&mut world, Tile::Middle, &GameObjBlueprint::PLAYER, Some(1));
world
}
fn add_object(size : &Size, objects : &mut Vec<GameObj>, blueprint : &'static GameObjBlueprint, time : FrameCount) -> bool {
let bounds = gen_circle_bounds(size, None, objects, blueprint);
if bounds.is_some() { objects.push(GameObj::from(&blueprint, bounds.unwrap(), time)); true } else { false }
}
pub fn add_objects(w : &mut World, tile : Tile, blueprint : &'static GameObjBlueprint, count : Option<i32>) {
let objects = &mut w.objects;
let time = w.time;
if count.is_none() {
loop { if !add_object(&w.size, objects, blueprint, time) { break } }
} else {
for _ in 0..count.unwrap() { add_object(&w.size, objects, blueprint, time); }
}
}
//maybe support circular bounds too
pub fn gen_circle_bounds(
size : &Size,
center_bounds : Option<&CircleBounds>,
objects : &Vec<GameObj>,
blueprint : &'static GameObjBlueprint
) -> Option<CircleBounds> {
for _ in 0..100 {
let r = rng_range(&blueprint.radius);
let coords = match center_bounds {
None => Point::new(
rng_range(&(r + blueprint.min_dist..size.x - r - blueprint.min_dist)),
rng_range(&(r + blueprint.min_dist..size.y - r - blueprint.min_dist))
),
Some(v) => {
let (angle, dist) = (rng_range(&(0.0..2.0*std::f32::consts::PI)), rng_range(&(0.0..v.r)));
Point::new(v.coords.x + angle.sin() * dist, v.coords.y + angle.cos() * dist)
}
};
let bounds = CircleBounds { coords, r };
if !(objects.iter().any(|obs| { obs.bounds.coords.dist(&bounds.coords) < obs.bounds.r + bounds.r + blueprint.min_dist})) { return Some(bounds) }
}
return None
}
|
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package main
import (
"context"
"log"
"time"
"golang.org/x/sync/errgroup"
)
var (
historicalJSONFilePath = "./data/historical.json"
currentJSONFilePath = "./data/current.json"
historicalCSVFilePath = "./data/historical.csv"
currentCSVFilePath = "./data/current.csv"
)
func getData(ctx context.Context, db *database) error {
g, ctx := errgroup.WithContext(ctx)
g.Go(func() error {
return getHistoricalData(ctx, db, historicalCSVFilePath)
})
g.Go(func() error {
return getCurrentData(ctx, db, currentCSVFilePath)
})
return g.Wait()
}
func main() {
log.SetFlags(log.Llongfile)
t := newTimer("setting up sqlite database")
db, err := newDatabase()
if err != nil {
log.Fatal(err)
}
t.end().reset("getting all the data")
defer t.end()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
err = getData(ctx, db)
if err != nil {
log.Fatal(err)
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 3 | package main
import (
"context"
"log"
"time"
"golang.org/x/sync/errgroup"
)
var (
historicalJSONFilePath = "./data/historical.json"
currentJSONFilePath = "./data/current.json"
historicalCSVFilePath = "./data/historical.csv"
currentCSVFilePath = "./data/current.csv"
)
func getData(ctx context.Context, db *database) error {
g, ctx := errgroup.WithContext(ctx)
g.Go(func() error {
return getHistoricalData(ctx, db, historicalCSVFilePath)
})
g.Go(func() error {
return getCurrentData(ctx, db, currentCSVFilePath)
})
return g.Wait()
}
func main() {
log.SetFlags(log.Llongfile)
t := newTimer("setting up sqlite database")
db, err := newDatabase()
if err != nil {
log.Fatal(err)
}
t.end().reset("getting all the data")
defer t.end()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
err = getData(ctx, db)
if err != nil {
log.Fatal(err)
}
}
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package com.hhwy.purchaseweb.contract.smagremp.controller;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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 com.hhwy.business.core.modelutil.ExecutionResult;
import com.hhwy.business.core.modelutil.ReturnCode;
import com.hhwy.framework.persistent.QueryResult;
import com.hhwy.purchaseweb.contract.smagremp.domain.SmAgreMpInfoDetail;
import com.hhwy.purchaseweb.contract.smagremp.domain.SmAgreMpVo;
import com.hhwy.purchaseweb.contract.smagremp.service.SmAgreMpService;
import com.hhwy.selling.domain.SmAgreMp;
/**
* SmAgreMpController
* @author hhwy
* @date 2016-09-24
* @version 1.0
*/
@RestController
@RequestMapping("/smAgreMpController")
public class SmAgreMpController {
public static final Logger log = LoggerFactory.getLogger(SmAgreMpController.class);
/**
* smAgreMpService
*/
@Autowired
private SmAgreMpService smAgreMpService;
/**
* 获取对象集合ScMpInfo
* @param consId
* @return ScMpInfo
*/
@RequestMapping( value = "/getScMpInfoList", method = RequestMethod.POST)
public List<SmAgreMpInfoDetail> getScMpInfoList(@RequestBody(required=false) Map<String,String> map) {
List<SmAgreMpInfoDetail> queryResult = null;
try {
queryResult = smAgreMpService.getScMpInfoList(map);
} catch (Exception e) {
// TODO: handle exception
log.error("分页查询列表失败",e); //记录异常日志，根据实际情况修改
}
return queryResult;
}
/**
* 分页获取对象SmAgreMp
* @param ID
* @return SmAgreMp
*/
@RequestMapping( value = "/page", method = RequestMethod.POST)
public Object getSmAgreMpByPage(@RequestBody(required=false) SmAgreMpVo smAgreMpVo) {
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 2 | package com.hhwy.purchaseweb.contract.smagremp.controller;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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 com.hhwy.business.core.modelutil.ExecutionResult;
import com.hhwy.business.core.modelutil.ReturnCode;
import com.hhwy.framework.persistent.QueryResult;
import com.hhwy.purchaseweb.contract.smagremp.domain.SmAgreMpInfoDetail;
import com.hhwy.purchaseweb.contract.smagremp.domain.SmAgreMpVo;
import com.hhwy.purchaseweb.contract.smagremp.service.SmAgreMpService;
import com.hhwy.selling.domain.SmAgreMp;
/**
* SmAgreMpController
* @author hhwy
* @date 2016-09-24
* @version 1.0
*/
@RestController
@RequestMapping("/smAgreMpController")
public class SmAgreMpController {
public static final Logger log = LoggerFactory.getLogger(SmAgreMpController.class);
/**
* smAgreMpService
*/
@Autowired
private SmAgreMpService smAgreMpService;
/**
* 获取对象集合ScMpInfo
* @param consId
* @return ScMpInfo
*/
@RequestMapping( value = "/getScMpInfoList", method = RequestMethod.POST)
public List<SmAgreMpInfoDetail> getScMpInfoList(@RequestBody(required=false) Map<String,String> map) {
List<SmAgreMpInfoDetail> queryResult = null;
try {
queryResult = smAgreMpService.getScMpInfoList(map);
} catch (Exception e) {
// TODO: handle exception
log.error("分页查询列表失败",e); //记录异常日志，根据实际情况修改
}
return queryResult;
}
/**
* 分页获取对象SmAgreMp
* @param ID
* @return SmAgreMp
*/
@RequestMapping( value = "/page", method = RequestMethod.POST)
public Object getSmAgreMpByPage(@RequestBody(required=false) SmAgreMpVo smAgreMpVo) {
ExecutionResult result = new ExecutionResult();
try {
QueryResult<SmAgreMp> queryResult = smAgreMpService.getSmAgreMpByPage(smAgreMpVo);
result.setCode(ReturnCode.RES_SUCCESS); //设置返回结果编码：成功
result.setFlag(true); //设置是否成功标识
result.setTotal(queryResult.getTotal()); //设置数据总条数
result.setRows(queryResult.getRows() == null ? queryResult.getData() : queryResult.getRows()); //设置数据列表
result.setMsg("分页查询列表成功！"); //设置返回消息，根据实际情况修改
} catch (Exception e) {
// TODO: handle exception
log.error("分页查询列表失败",e); //记录异常日志，根据实际情况修改
result.setCode(ReturnCode.RES_FAILED); //设置返回结果编码：失败
result.setFlag(false); //设置是否成功标识
result.setRows(new Object[]{}); //设置返回结果为空
result.setTotal(0); //设置数据总条数为0
result.setMsg("分页查询列表失败！"); //设置返回消息，根据实际情况修改
return result;
}
return result;
}
/**
* 根据ID获取对象SmAgreMp
* @param ID
* @return SmAgreMp
*/
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
public Object getSmAgreMpById(@PathVariable String id) {
ExecutionResult result = new ExecutionResult();
try {
SmAgreMp smAgreMp = smAgreMpService.getSmAgreMpById(id);
result.setCode(ReturnCode.RES_SUCCESS); //设置返回结果编码：成功
result.setFlag(true); //设置是否成功标识
result.setData(smAgreMp); //设置数据实体
result.setMsg("查询成功！"); //设置返回消息，根据实际情况修改
} catch (Exception e) {
// TODO: handle exception
log.error("查询失败",e); //记录异常日志，根据实际情况修改
result.setCode(ReturnCode.RES_FAILED); //设置返回结果编码：失败
result.setFlag(false); //设置是否成功标识
result.setData(null); //设置返回结果为空
result.setMsg("查询失败！"); //设置返回消息，根据实际情况修改
return result;
}
return result;
}
/**
* 添加对象SmAgreMp
* @param 实体对象
*/
@RequestMapping( method = RequestMethod.POST)
public Object saveSmAgreMp(@RequestBody SmAgreMp smAgreMp) {
ExecutionResult result = new ExecutionResult();
try {
smAgreMpService.saveSmAgreMp(smAgreMp);
result.setCode(ReturnCode.RES_SUCCESS); //设置返回结果编码：成功
result.setFlag(true); //设置是否成功标识
result.setMsg("保存成功！"); //设置返回消息，根据实际情况修改
} catch (Exception e) {
// TODO: handle exception
log.error("保存失败",e); //记录异常日志，根据实际情况修改
result.setCode(ReturnCode.RES_FAILED); //设置返回结果编码：失败
result.setFlag(false); //设置是否成功标识
result.setMsg("保存失败！"); //设置返回消息，根据实际情况修改
return result;
}
return result;
}
/**
* 更新对象SmAgreMp
* @param 实体对象
*/
@RequestMapping( method = RequestMethod.PUT)
public Object updateSmAgreMp(@RequestBody SmAgreMp smAgreMp) {
ExecutionResult result = new ExecutionResult();
try {
smAgreMpService.updateSmAgreMp(smAgreMp);
result.setCode(ReturnCode.RES_SUCCESS); //设置返回结果编码：成功
result.setFlag(true); //设置是否成功标识
result.setMsg("更新成功！"); //设置返回消息，根据实际情况修改
} catch (Exception e) {
// TODO: handle exception
log.error("更新失败",e); //记录异常日志，根据实际情况修改
result.setCode(ReturnCode.RES_FAILED); //设置返回结果编码：失败
result.setFlag(false); //设置是否成功标识
result.setMsg("更新失败！"); //设置返回消息，根据实际情况修改
return result;
}
return result;
}
/**
* 删除对象SmAgreMp
* @param id
*/
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
public Object deleteSmAgreMp(@PathVariable String id) {
ExecutionResult result = new ExecutionResult();
try {
smAgreMpService.deleteSmAgreMp(new String[]{id});
result.setCode(ReturnCode.RES_SUCCESS); //设置返回结果编码：成功
result.setFlag(true); //设置是否成功标识
result.setMsg("删除成功！"); //设置返回消息，根据实际情况修改
} catch (Exception e) {
// TODO: handle exception
log.error("删除失败",e); //记录异常日志，根据实际情况修改
result.setCode(ReturnCode.RES_FAILED); //设置返回结果编码：失败
result.setFlag(false); //设置是否成功标识
result.setMsg("删除失败！"); //设置返回消息，根据实际情况修改
return result;
}
return result;
}
} |
Below is an extract from a Ruby program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Ruby code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Ruby concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., metaprogramming, blocks). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Ruby. It should be similar to a school exercise, a tutorial, or a Ruby course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Ruby. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
require 'date'
require 'mongo'
require 'uri'
accounts = (2000_0000_000...2000_1000_000).lazy
names = ("aaaaa".."zzzzz").lazy
balances = (1..9999).lazy.to_a
begin
(Date.new(2013, 03, 01)..Date.today).each do |date|
@balance = balances.shuffle
@folder = date.strftime("%d-%m-%Y")
names.rewind
accounts.each do |acc|
@hash = {:account => acc, :name => names.next, :balance => @balance.sample}
end
end
rescue Exception => e
puts e.message
end
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| ruby | 2 | require 'date'
require 'mongo'
require 'uri'
accounts = (2000_0000_000...2000_1000_000).lazy
names = ("aaaaa".."zzzzz").lazy
balances = (1..9999).lazy.to_a
begin
(Date.new(2013, 03, 01)..Date.today).each do |date|
@balance = balances.shuffle
@folder = date.strftime("%d-%m-%Y")
names.rewind
accounts.each do |acc|
@hash = {:account => acc, :name => names.next, :balance => @balance.sample}
end
end
rescue Exception => e
puts e.message
end
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#ifndef MATH_FUNCS_H
#define MATH_FUNCS_H
void CPU::Add ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a + b;
s_.Push (res);
}
void CPU::Sub ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a - b;
s_.Push (res);
}
void CPU::Mul ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a * b;
s_.Push (res);
}
void CPU::Div ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
assert (b != 0 && "Division by zero!");
res = a / b;
s_.Push (res);
}
void CPU::Sin ()
{
double a = 0, res = 0;
a = s_.Pop ();
res = sin (a);
s_.Push (res);
}
void CPU::Cos ()
{
double a = 0, res = 0;
a = s_.Pop ();
res = cos (a);
s_.Push (res);
}
void CPU::Sqrt ()
{
double a = 0, res = 0;
a = s_.Pop ();
assert (a >= 0 && "Square root of a negative number!");
res = sqrt (a);
s_.Push (res);
}
#endif
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 3 | #ifndef MATH_FUNCS_H
#define MATH_FUNCS_H
void CPU::Add ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a + b;
s_.Push (res);
}
void CPU::Sub ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a - b;
s_.Push (res);
}
void CPU::Mul ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
res = a * b;
s_.Push (res);
}
void CPU::Div ()
{
double a = 0, b = 0, res = 0;
a = s_.Pop ();
b = s_.Pop ();
assert (b != 0 && "Division by zero!");
res = a / b;
s_.Push (res);
}
void CPU::Sin ()
{
double a = 0, res = 0;
a = s_.Pop ();
res = sin (a);
s_.Push (res);
}
void CPU::Cos ()
{
double a = 0, res = 0;
a = s_.Pop ();
res = cos (a);
s_.Push (res);
}
void CPU::Sqrt ()
{
double a = 0, res = 0;
a = s_.Pop ();
assert (a >= 0 && "Square root of a negative number!");
res = sqrt (a);
s_.Push (res);
}
#endif |
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace Botble\SeoHelper;
use Illuminate\Support\Arr;
use Botble\Base\Facades\BaseHelper;
use Botble\Base\Models\BaseModel;
use Botble\SeoHelper\Contracts\SeoHelperContract;
use Botble\SeoHelper\Contracts\SeoMetaContract;
use Botble\SeoHelper\Contracts\SeoOpenGraphContract;
use Botble\SeoHelper\Contracts\SeoTwitterContract;
use Exception;
use Illuminate\Http\Request;
use Botble\Base\Facades\MetaBox;
class SeoHelper implements SeoHelperContract
{
public function __construct(
protected SeoMetaContract $seoMeta,
protected SeoOpenGraphContract $seoOpenGraph,
protected SeoTwitterContract $seoTwitter
) {
$this->openGraph()->addProperty('type', 'website');
}
public function setSeoMeta(SeoMetaContract $seoMeta): self
{
$this->seoMeta = $seoMeta;
return $this;
}
public function setSeoOpenGraph(SeoOpenGraphContract $seoOpenGraph): self
{
$this->seoOpenGraph = $seoOpenGraph;
return $this;
}
public function setSeoTwitter(SeoTwitterContract $seoTwitter): self
{
$this->seoTwitter = $seoTwitter;
return $this;
}
public function openGraph(): SeoOpenGraphContract
{
return $this->seoOpenGraph;
}
public function setTitle(string|null $title, string|null $siteName = null, string|null $separator = null): self
{
$this->meta()->setTitle($title, $siteName, $separator);
$this->openGraph()->setTitle($title);
if ($siteName) {
$this->openGraph()->setSiteName($siteName);
}
$this->twitter()->setTitle($title);
return $this;
}
public function meta(): SeoMetaContract
{
return $this->seoMeta;
}
public function twitter(): SeoTwitterContract
{
return $this->seoTwitter;
}
public function getTitle(): string|null
{
return $this->meta()->getTitle();
}
public function getDescription(): string|null
{
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 | <?php
namespace Botble\SeoHelper;
use Illuminate\Support\Arr;
use Botble\Base\Facades\BaseHelper;
use Botble\Base\Models\BaseModel;
use Botble\SeoHelper\Contracts\SeoHelperContract;
use Botble\SeoHelper\Contracts\SeoMetaContract;
use Botble\SeoHelper\Contracts\SeoOpenGraphContract;
use Botble\SeoHelper\Contracts\SeoTwitterContract;
use Exception;
use Illuminate\Http\Request;
use Botble\Base\Facades\MetaBox;
class SeoHelper implements SeoHelperContract
{
public function __construct(
protected SeoMetaContract $seoMeta,
protected SeoOpenGraphContract $seoOpenGraph,
protected SeoTwitterContract $seoTwitter
) {
$this->openGraph()->addProperty('type', 'website');
}
public function setSeoMeta(SeoMetaContract $seoMeta): self
{
$this->seoMeta = $seoMeta;
return $this;
}
public function setSeoOpenGraph(SeoOpenGraphContract $seoOpenGraph): self
{
$this->seoOpenGraph = $seoOpenGraph;
return $this;
}
public function setSeoTwitter(SeoTwitterContract $seoTwitter): self
{
$this->seoTwitter = $seoTwitter;
return $this;
}
public function openGraph(): SeoOpenGraphContract
{
return $this->seoOpenGraph;
}
public function setTitle(string|null $title, string|null $siteName = null, string|null $separator = null): self
{
$this->meta()->setTitle($title, $siteName, $separator);
$this->openGraph()->setTitle($title);
if ($siteName) {
$this->openGraph()->setSiteName($siteName);
}
$this->twitter()->setTitle($title);
return $this;
}
public function meta(): SeoMetaContract
{
return $this->seoMeta;
}
public function twitter(): SeoTwitterContract
{
return $this->seoTwitter;
}
public function getTitle(): string|null
{
return $this->meta()->getTitle();
}
public function getDescription(): string|null
{
return $this->meta()->getDescription();
}
public function setDescription($description): self
{
$description = BaseHelper::cleanShortcodes($description);
$this->meta()->setDescription($description);
$this->openGraph()->setDescription($description);
$this->twitter()->setDescription($description);
return $this;
}
public function __toString()
{
return $this->render();
}
public function render()
{
return implode(
PHP_EOL,
array_filter([
$this->meta()->render(),
$this->openGraph()->render(),
$this->twitter()->render(),
])
);
}
public function saveMetaData(string $screen, Request $request, BaseModel $object): bool
{
if (in_array(get_class($object), config('packages.seo-helper.general.supported', [])) && $request->has(
'seo_meta'
)) {
try {
if (empty($request->input('seo_meta'))) {
MetaBox::deleteMetaData($object, 'seo_meta');
return false;
}
$seoMeta = $request->input('seo_meta', []);
if (! Arr::get($seoMeta, 'seo_title')) {
Arr::forget($seoMeta, 'seo_title');
}
if (! Arr::get($seoMeta, 'seo_description')) {
Arr::forget($seoMeta, 'seo_description');
}
if (! empty($seoMeta)) {
MetaBox::saveMetaBoxData($object, 'seo_meta', $seoMeta);
} else {
MetaBox::deleteMetaData($object, 'seo_meta');
}
return true;
} catch (Exception) {
return false;
}
}
return false;
}
public function deleteMetaData(string $screen, BaseModel $object): bool
{
try {
if (in_array(get_class($object), config('packages.seo-helper.general.supported', []))) {
MetaBox::deleteMetaData($object, 'seo_meta');
}
return true;
} catch (Exception) {
return false;
}
}
public function registerModule(array|string $model): self
{
if (! is_array($model)) {
$model = [$model];
}
config([
'packages.seo-helper.general.supported' => array_merge(
config('packages.seo-helper.general.supported', []),
$model
),
]);
return $this;
}
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Table;
using Microsoft.WindowsAzure.Storage.Queue;
using System.Configuration;
namespace MSGorilla.Library.Azure
{
public static class AzureFactory
{
public enum MSGorillaTable{
Homeline,
Userline,
PublicSquareLine,
EventLine,
Reply,
ReplyNotification,
ReplyArchive
}
public const string QueueName = "messagequeue";
private static CloudStorageAccount _storageAccount;
private static Dictionary<MSGorillaTable, string> _dict;
static AzureFactory()
{
string connectionString = CloudConfigurationManager.GetSetting("StorageConnectionString");
//string connectionString = ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString;
_storageAccount = CloudStorageAccount.Parse(connectionString);
_dict = new Dictionary<MSGorillaTable, string>();
_dict.Add(MSGorillaTable.Homeline, "Homeline");
_dict.Add(MSGorillaTable.Userline, "Userline");
_dict.Add(MSGorillaTable.EventLine, "EventlineTweet");
_dict.Add(MSGorillaTable.PublicSquareLine, "PublicSquareline");
_dict.Add(MSGorillaTable.Reply, "Reply");
_dict.Add(MSGorillaTable.ReplyNotification, "ReplyNotification");
_dict.Add(MSGorillaTable.ReplyArchive, "ReplyArchive");
}
public static CloudTable GetTable(MSGorillaTable table)
{
var client = _storageAccount.CreateCloudTableClient();
var aztable = client.GetTableReference(_dict[table]);
aztable.CreateIfNotExists();
return aztable;
}
public static Cloud
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 2 | using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Table;
using Microsoft.WindowsAzure.Storage.Queue;
using System.Configuration;
namespace MSGorilla.Library.Azure
{
public static class AzureFactory
{
public enum MSGorillaTable{
Homeline,
Userline,
PublicSquareLine,
EventLine,
Reply,
ReplyNotification,
ReplyArchive
}
public const string QueueName = "messagequeue";
private static CloudStorageAccount _storageAccount;
private static Dictionary<MSGorillaTable, string> _dict;
static AzureFactory()
{
string connectionString = CloudConfigurationManager.GetSetting("StorageConnectionString");
//string connectionString = ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString;
_storageAccount = CloudStorageAccount.Parse(connectionString);
_dict = new Dictionary<MSGorillaTable, string>();
_dict.Add(MSGorillaTable.Homeline, "Homeline");
_dict.Add(MSGorillaTable.Userline, "Userline");
_dict.Add(MSGorillaTable.EventLine, "EventlineTweet");
_dict.Add(MSGorillaTable.PublicSquareLine, "PublicSquareline");
_dict.Add(MSGorillaTable.Reply, "Reply");
_dict.Add(MSGorillaTable.ReplyNotification, "ReplyNotification");
_dict.Add(MSGorillaTable.ReplyArchive, "ReplyArchive");
}
public static CloudTable GetTable(MSGorillaTable table)
{
var client = _storageAccount.CreateCloudTableClient();
var aztable = client.GetTableReference(_dict[table]);
aztable.CreateIfNotExists();
return aztable;
}
public static CloudQueue GetQueue()
{
var client = _storageAccount.CreateCloudQueueClient();
var azqueue = client.GetQueueReference(QueueName);
azqueue.CreateIfNotExists();
return azqueue;
}
}
}
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//OffBoardBlinkG2
#include <msp430g2553.h>
/**
* blink.c
*/
int temp;
void main(void)
{
WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer
P1DIR |= 0x41; // configure P1.0 as output
P1DIR &= 0xF7;
P1REN |= BIT3;
P1OUT |= 0x08;
volatile unsigned int j;
while(1)
{
temp = P1IN & BIT3; //For this project, an off board button is providing an input for the chip's code
//When the button is pressed, the LED P1.0 will blink
if (temp == BIT3)
{
P1OUT &= ~BIT0;
}
else
{
P1OUT ^= 0x01;
}
P1OUT ^= 0x40; //Regardless of the button, LED P1.6 will blink
j = 10000; // SW Delay
do j--;
while(j != 0);
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 3 |
//OffBoardBlinkG2
#include <msp430g2553.h>
/**
* blink.c
*/
int temp;
void main(void)
{
WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer
P1DIR |= 0x41; // configure P1.0 as output
P1DIR &= 0xF7;
P1REN |= BIT3;
P1OUT |= 0x08;
volatile unsigned int j;
while(1)
{
temp = P1IN & BIT3; //For this project, an off board button is providing an input for the chip's code
//When the button is pressed, the LED P1.0 will blink
if (temp == BIT3)
{
P1OUT &= ~BIT0;
}
else
{
P1OUT ^= 0x01;
}
P1OUT ^= 0x40; //Regardless of the button, LED P1.6 will blink
j = 10000; // SW Delay
do j--;
while(j != 0);
}
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace myExpression
{
public class myExp
{
#region 定义栈
private Stack<string> OPTR = new Stack<string>(); //数字栈
private Stack<string> OPND = new Stack<string>(); //符号栈
#endregion
#region 判断是否为数字
public bool IsNumber(string ch)
{
Regex RegInput = new Regex(@"^[0-9\.]"); //用正则表达式判断
if (RegInput.IsMatch(ch.ToString()))
{
return true;
}
else
return false;
}
#endregion
#region 定义运算符优先级
public static int priority(String Operator)
{
if (Operator == ("+") || Operator == ("-"))
{
return 1;
}
else if (Operator == ("*") || Operator == ("/") || Operator == ("%"))
{
return 2;
}
else if (Operator == ("^"))
{
return 3;
}
else
{
return 0;
}
}
#endregion
#region 比较运算符的优先级
public int CompareOperate(string ch, string stackCh)
{
int intCh = priority(ch.ToString());
int intSCh = priority(stackCh.ToString());
if (intCh == intSCh)
{
return 0;
}
else if (intCh < intSCh)
{
return -1;
}
else if (intCh > intSCh)
{
return 1;
}
else
return -2;
}
#endregion
#region 调用getResult将最后结果显示
public string GetExpression(string InputString)
{
bool Hasop = true; //这个布尔变量用于判断数字之后是否有符号，作用是用来得到9以上数字
InputString += "#"; //在
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 3 | using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace myExpression
{
public class myExp
{
#region 定义栈
private Stack<string> OPTR = new Stack<string>(); //数字栈
private Stack<string> OPND = new Stack<string>(); //符号栈
#endregion
#region 判断是否为数字
public bool IsNumber(string ch)
{
Regex RegInput = new Regex(@"^[0-9\.]"); //用正则表达式判断
if (RegInput.IsMatch(ch.ToString()))
{
return true;
}
else
return false;
}
#endregion
#region 定义运算符优先级
public static int priority(String Operator)
{
if (Operator == ("+") || Operator == ("-"))
{
return 1;
}
else if (Operator == ("*") || Operator == ("/") || Operator == ("%"))
{
return 2;
}
else if (Operator == ("^"))
{
return 3;
}
else
{
return 0;
}
}
#endregion
#region 比较运算符的优先级
public int CompareOperate(string ch, string stackCh)
{
int intCh = priority(ch.ToString());
int intSCh = priority(stackCh.ToString());
if (intCh == intSCh)
{
return 0;
}
else if (intCh < intSCh)
{
return -1;
}
else if (intCh > intSCh)
{
return 1;
}
else
return -2;
}
#endregion
#region 调用getResult将最后结果显示
public string GetExpression(string InputString)
{
bool Hasop = true; //这个布尔变量用于判断数字之后是否有符号，作用是用来得到9以上数字
InputString += "#"; //在字符串最后加上标记符#
#region 入栈
for (int i = 0; i < InputString.Length; i++)//遍历每一个字符
{
string ch = InputString[i].ToString();
if (ch == "#") //判断是否遍历到最后一个字符
{
break; //是则跳出循环
}
else
{
string chNext = InputString[i + 1].ToString();//下一个字符
#region "数字的判别与处理"
if (IsNumber(ch) == true) //如果是数字的话，要把数字放入数字栈中
{
if (Hasop == true)//如果数字之后有符号，意味着个位数,数字栈顶字符串不变更
{
OPTR.Push(ch);
Hasop = false; //这个数字之后是什么还未知，所以先将其定义为数字
}
else
{
OPTR.Push(OPTR.Pop() + ch);//如果数字之后没有符号，则数字栈顶字符串加上新字符串,也就是多位数.
}
}
#endregion
#region "符号的判别与处理"
else if (ch == "(")
{
OPND.Push(ch);//左括号压入栈
}
else if (ch == ")")
{
while (OPND.Peek() != "(") //当下一个字符不为左括号
{
string mark = OPND.Pop().ToString();
string op1 = OPTR.Pop().ToString();
string op2 = OPTR.Pop().ToString();//相当于计算括号里的内容
OPTR.Push(getResult(mark, op1, op2));//调用getResult方法，获取计算结果值，并推入数字栈
}
OPND.Pop(); //弹出左括号
}
else if (ch == "+" || ch == "-" || ch == "*" || ch == "/" || ch == "^" || ch == "%")
{
if (chNext == "-") //处理负号
{
OPND.Push(ch);
OPTR.Push(chNext);
i += 1;
Hasop = false; //输入了符号，Hasop为false
}
else
{
if (OPND.Count == 0)
{
OPND.Push(ch);
}
else if (OPND.Peek() == "(")
{
OPND.Push(ch);
}
else if (CompareOperate(ch, OPND.Peek()) == 1)
{
OPND.Push(ch);
}
else if (CompareOperate(ch, OPND.Peek()) == 0)//若优先级一样
{
string mark = OPND.Pop().ToString();
string op1 = OPTR.Pop().ToString();
string op2 = OPTR.Pop().ToString();
OPTR.Push(getResult(mark, op1, op2));//调用getResult方法，获取计算结果值，并推入数字栈
OPND.Push(ch); //把符号推入符号栈
}
else if (CompareOperate(ch, OPND.Peek()) == -1)//若优先级较小
{
int com = -1;
while (com == -1 || com == 0)
{
string mark = OPND.Pop().ToString();
string op1 = OPTR.Pop().ToString();
string op2 = OPTR.Pop().ToString();
OPTR.Push(getResult(mark, op1, op2));//调用getResult方法，获取计算结果值，并推入数字栈
if (OPND.Count != 0)
{
com = CompareOperate(ch, OPND.Peek());
}
else
{
break;
}
}
OPND.Push(ch);//把符号推入符号栈
}
Hasop = true;//输入了运算符，HasMark为true
}
}
}
#endregion
}
#endregion
#region "返回计算结果值"
for (int i = 0; i < OPND.Count + 1; i++) //循环得出结果
{
try
{
string mark = OPND.Pop().ToString();
string op1 = OPTR.Pop().ToString();
string op2 = OPTR.Pop().ToString();
OPTR.Push(getResult(mark, op1, op2));//调用getResult方法，获取计算结果值，并推入数字栈
}
catch
{
return "Error";
}
}
return OPTR.Pop(); //返回最终结果
#endregion
}
#endregion
#region getResult返回运算结果
public static string getResult(String Myoperator, String a, String b)
{
try
{
string op = Myoperator;
string rs = string.Empty;
decimal x = System.Convert.ToDecimal(b);
decimal y = System.Convert.ToDecimal(a);
decimal result = 0;
switch (op)
{
case "+": result = x + y; break;
case "-": result = x - y; break;
case "*": result = x * y; break;
case "/": result = x / y; break;
case "%": result = x % y; break;
case "^": result = Convert.ToDecimal(Math.Pow(Convert.ToDouble(x), Convert.ToDouble(y))); break;
default: result = 0; break;
}
return rs + result;
}
catch (IndexOutOfRangeException)//超出范围
{
return "Error!";
}
}
#endregion
}
}
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import Dropship from "../objects/dropship";
import Base from "../objects/base";
export enum PlayerType {
Human = 0,
AI
}
export class Player {
gameScene: GameScene;
playerType: PlayerType;
team: number;
units: Phaser.GameObjects.Group;
dropship: Dropship;
base: Base;
constructor(gameScene: GameScene, playerType: PlayerType, team: number) {
this.gameScene = gameScene;
this.playerType = playerType;
this.team = team;
this.units = new Phaser.GameObjects.Group();
this.dropship = null;
this.base = null;
}
created() {
if(this.playerType == PlayerType.Human) {
this.dropship = this.gameScene.addUnit(new Dropship(this.gameScene,
this.team,
this.gameScene.tilemap.spawns[this.team].x,
this.gameScene.tilemap.spawns[this.team].y - 100));
this.base = this.gameScene.addUnit(new Base(this.gameScene,
this.team,
this.gameScene.tilemap.spawns[this.team].x,
this.gameScene.tilemap.spawns[this.team].y - 45));
}
}
}
export default Player;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 2 | import Dropship from "../objects/dropship";
import Base from "../objects/base";
export enum PlayerType {
Human = 0,
AI
}
export class Player {
gameScene: GameScene;
playerType: PlayerType;
team: number;
units: Phaser.GameObjects.Group;
dropship: Dropship;
base: Base;
constructor(gameScene: GameScene, playerType: PlayerType, team: number) {
this.gameScene = gameScene;
this.playerType = playerType;
this.team = team;
this.units = new Phaser.GameObjects.Group();
this.dropship = null;
this.base = null;
}
created() {
if(this.playerType == PlayerType.Human) {
this.dropship = this.gameScene.addUnit(new Dropship(this.gameScene,
this.team,
this.gameScene.tilemap.spawns[this.team].x,
this.gameScene.tilemap.spawns[this.team].y - 100));
this.base = this.gameScene.addUnit(new Base(this.gameScene,
this.team,
this.gameScene.tilemap.spawns[this.team].x,
this.gameScene.tilemap.spawns[this.team].y - 45));
}
}
}
export default Player; |
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
pub struct Solution;
// ------------------------------------------------------ snip ------------------------------------------------------ //
use std::convert::TryInto;
impl Solution {
pub fn can_finish(num_courses: i32, prerequisites: Vec<Vec<i32>>) -> bool {
// Build graph.
let mut graph = vec![Vec::new(); num_courses as _];
for edge in prerequisites {
let [from, to]: [_; 2] = edge.as_slice().try_into().unwrap();
graph[from as usize].push(to);
}
// Detect cycle.
let mut states = vec![0_u8; num_courses as _];
let mut stack = Vec::new();
for mut node in 0..num_courses {
if states[node as usize] == 0 {
'outer: loop {
states[node as usize] = 1;
let mut iter = graph[node as usize].iter().copied();
// Return address.
loop {
while let Some(next) = iter.next() {
let state = states[next as usize];
if state == 0 {
stack.push((node, iter));
node = next;
continue 'outer;
} else if state == 1 {
return false;
}
}
states[node as usize] = 2;
// Apply continuation.
if let Some((new_node, new_iter)) = stack.pop() {
node = new_node;
iter = new_iter;
} else {
break 'outer;
}
}
}
}
}
true
}
}
// ------------------------------------------------------ snip ------------------------------------------------------ //
impl sup
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | pub struct Solution;
// ------------------------------------------------------ snip ------------------------------------------------------ //
use std::convert::TryInto;
impl Solution {
pub fn can_finish(num_courses: i32, prerequisites: Vec<Vec<i32>>) -> bool {
// Build graph.
let mut graph = vec![Vec::new(); num_courses as _];
for edge in prerequisites {
let [from, to]: [_; 2] = edge.as_slice().try_into().unwrap();
graph[from as usize].push(to);
}
// Detect cycle.
let mut states = vec![0_u8; num_courses as _];
let mut stack = Vec::new();
for mut node in 0..num_courses {
if states[node as usize] == 0 {
'outer: loop {
states[node as usize] = 1;
let mut iter = graph[node as usize].iter().copied();
// Return address.
loop {
while let Some(next) = iter.next() {
let state = states[next as usize];
if state == 0 {
stack.push((node, iter));
node = next;
continue 'outer;
} else if state == 1 {
return false;
}
}
states[node as usize] = 2;
// Apply continuation.
if let Some((new_node, new_iter)) = stack.pop() {
node = new_node;
iter = new_iter;
} else {
break 'outer;
}
}
}
}
}
true
}
}
// ------------------------------------------------------ snip ------------------------------------------------------ //
impl super::Solution for Solution {
fn can_finish(num_courses: i32, prerequisites: Vec<Vec<i32>>) -> bool {
Self::can_finish(num_courses, prerequisites)
}
}
#[cfg(test)]
mod tests {
#[test]
fn test_solution() {
super::super::tests::run::<super::Solution>();
}
}
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
public class Product {
int code;
double price;
boolean eligible;
int quantity;
String name;
Product(int ncode, double nprice, boolean eligibility, String newname) {
code = ncode;
price = nprice;
eligible = eligibility;
name = newname;
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 2 |
public class Product {
int code;
double price;
boolean eligible;
int quantity;
String name;
Product(int ncode, double nprice, boolean eligibility, String newname) {
code = ncode;
price = nprice;
eligible = eligibility;
name = newname;
}
|
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# HPPython_Chapter7_9
ハイパフォーマンスPython輪読会用
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 1 | # HPPython_Chapter7_9
ハイパフォーマンスPython輪読会用
|
Below is an extract from a Swift program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Swift code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Swift concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., protocols, extensions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Swift. It should be similar to a school exercise, a tutorial, or a Swift course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Swift. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// JsonToModelParser.swift
// FitnessNotes
//
// Created by <NAME> on 5/3/16.
// Copyright © 2016 SunY. All rights reserved.
//
import Foundation
import SwiftyJSON
import CoreData
import CocoaLumberjack
class JsonToModelParser {
func parseJsonFileToJSONObject() ->JSON?{
let path = NSBundle.mainBundle().pathForResource("ExerciseLog", ofType: "json")
guard let filePath = path else {
DDLogError("Cannot find \"ExerciseLog.jon\" in the bundle")
return nil
}
let data = NSData(contentsOfFile: filePath)
guard let jsonData = data else { return nil }
return JSON(data: jsonData)
}
func saveJsonToPreloadExercise(withContext moc: NSManagedObjectContext, exeJson: JSON) {
for (bodypart, exerciseJson) in exeJson.dictionaryValue {
let entity = BodyPart.insertBodyPartIntoContext(moc, name: bodypart)
let exerciseEntities = exerciseJson.arrayValue.map({ (jsonItem) -> Exercise in
Exercise.insertExerciseIntoContext(moc, name: jsonItem.stringValue, bodyPart: entity)
})
entity.exercise = NSSet(array: exerciseEntities)
}
moc.performSaveOrRollback()
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| swift | 2 | //
// JsonToModelParser.swift
// FitnessNotes
//
// Created by <NAME> on 5/3/16.
// Copyright © 2016 SunY. All rights reserved.
//
import Foundation
import SwiftyJSON
import CoreData
import CocoaLumberjack
class JsonToModelParser {
func parseJsonFileToJSONObject() ->JSON?{
let path = NSBundle.mainBundle().pathForResource("ExerciseLog", ofType: "json")
guard let filePath = path else {
DDLogError("Cannot find \"ExerciseLog.jon\" in the bundle")
return nil
}
let data = NSData(contentsOfFile: filePath)
guard let jsonData = data else { return nil }
return JSON(data: jsonData)
}
func saveJsonToPreloadExercise(withContext moc: NSManagedObjectContext, exeJson: JSON) {
for (bodypart, exerciseJson) in exeJson.dictionaryValue {
let entity = BodyPart.insertBodyPartIntoContext(moc, name: bodypart)
let exerciseEntities = exerciseJson.arrayValue.map({ (jsonItem) -> Exercise in
Exercise.insertExerciseIntoContext(moc, name: jsonItem.stringValue, bodyPart: entity)
})
entity.exercise = NSSet(array: exerciseEntities)
}
moc.performSaveOrRollback()
}
} |
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package com.baier.toh;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class MoveCounterTest {
@Test
public void towersOfHanoi_5discTest() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
// when
int actual = moveCounter.countMovesForDisc(5);
// then
assertEquals(31, actual);
}
@Test
public void towersOfHanoi_MultipleTestWithSameNumber() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
MoveCounter moveCounter2 = givenWeHaveMoveCounter();
// when
int actual = moveCounter.countMovesForDisc(3);
int actual2 = moveCounter2.countMovesForDisc(3);
// then
assertEquals(7, actual);
assertEquals(7, actual2);
}
@Test(timeout = 30000)
public void towersOfHanoi_64disc() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
// when
moveCounter.countMovesForDisc(64);
//then
//? timeout, why?
}
private MoveCounter givenWeHaveMoveCounter() {
return new MoveCounter();
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 2 | package com.baier.toh;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class MoveCounterTest {
@Test
public void towersOfHanoi_5discTest() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
// when
int actual = moveCounter.countMovesForDisc(5);
// then
assertEquals(31, actual);
}
@Test
public void towersOfHanoi_MultipleTestWithSameNumber() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
MoveCounter moveCounter2 = givenWeHaveMoveCounter();
// when
int actual = moveCounter.countMovesForDisc(3);
int actual2 = moveCounter2.countMovesForDisc(3);
// then
assertEquals(7, actual);
assertEquals(7, actual2);
}
@Test(timeout = 30000)
public void towersOfHanoi_64disc() {
// given
MoveCounter moveCounter = givenWeHaveMoveCounter();
// when
moveCounter.countMovesForDisc(64);
//then
//? timeout, why?
}
private MoveCounter givenWeHaveMoveCounter() {
return new MoveCounter();
}
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using GameEngine;
using GameEngine.Layers;
using System.Runtime.InteropServices;
namespace GameEngine.Core
{
public class EntryPoint
{
private readonly Application _app;
private readonly string[] _args;
public EntryPoint(Application app, string[] args)
{
_app = app;
_args = args;
Log.CoreLogger.Warn("Init");
Log.ClientLogger.Warn("Init");
_app.Run();
_app.Dispose();
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 1 | using GameEngine;
using GameEngine.Layers;
using System.Runtime.InteropServices;
namespace GameEngine.Core
{
public class EntryPoint
{
private readonly Application _app;
private readonly string[] _args;
public EntryPoint(Application app, string[] args)
{
_app = app;
_args = args;
Log.CoreLogger.Warn("Init");
Log.ClientLogger.Warn("Init");
_app.Run();
_app.Dispose();
}
}
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CountSubstringOccurrences
{
class Program
{
static void Main(string[] args)
{
string text = Console.ReadLine().ToUpper();
string stringToFind = Console.ReadLine().ToUpper();
int count = 0;
for (int i = 0; i <= text.Length-stringToFind.Length; i++)
{
string subString = text.Substring(i, stringToFind.Length);
if (subString == stringToFind)
count++;
}
Console.WriteLine(count);
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 4 | using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CountSubstringOccurrences
{
class Program
{
static void Main(string[] args)
{
string text = Console.ReadLine().ToUpper();
string stringToFind = Console.ReadLine().ToUpper();
int count = 0;
for (int i = 0; i <= text.Length-stringToFind.Length; i++)
{
string subString = text.Substring(i, stringToFind.Length);
if (subString == stringToFind)
count++;
}
Console.WriteLine(count);
}
}
}
|
Below is an extract from an HTML document. Evaluate whether it has a high educational value and could help teach web development. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document contains valid HTML markup, even if it's not educational, like boilerplate code or standard tags.
- Add another point if the document addresses practical HTML concepts and uses semantic elements appropriately.
- Award a third point if the document is suitable for educational use and introduces key web concepts, even if the topic is somewhat advanced (e.g., forms, metadata). The code should be well-structured and use clear, descriptive naming.
- Give a fourth point if the document is self-contained and highly relevant to teaching HTML. It should be similar to a school exercise, a tutorial, or an HTML course section for early learners.
- Grant a fifth point if the document is outstanding in its educational value and is perfectly suited for teaching HTML to beginners. It should be well-organized, easy to understand, and ideally include some explanatory comments or demonstrate best practices in HTML structure.
The extract:
<html>
<head><meta charset="utf-8"><title>[isabelle] Another limitation of HOL: Binding the type va... · Mirror: Isabelle Users Mailing List · Zulip Chat Archive</title></head>
<h2>Stream: <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/index.html">Mirror: Isabelle Users Mailing List</a></h2>
<h3>Topic: <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/topic/.5Bisabelle.5D.20Another.20limitation.20of.20HOL.3A.20Binding.20the.20type.20va.2E.2E.2E.html">[isabelle] Another limitation of HOL: Binding the type va...</a></h3>
<hr>
<base href="https://isabelle.zulipchat.com/">
<head><link href="http://isabelle.systems/zulip-archive/style.css" rel="stylesheet"></head>
<a name="322160390"></a>
<h4><a href="https://isabelle.zulipchat.com/#narrow/stream/247541-Mirror%3A%20Isabelle%20Users%20Mailing%20List/topic/%5Bisabelle%5D%20Another%20limitation%20of%20HOL%3A%20Binding%20the%20type%20va.../near/322160390" class="zl"><img src="http://isabelle.systems/zulip-archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Email Gateway <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/topic/.5Bisabelle.5D.20Another.20limitation.20of.20HOL.3A.20Binding.20the.20type.20va.2E.2E.2E.html#322160390">(Jan 18 2023 at 21:50)</a>:</h4>
<p>From: <NAME> <<a href="mailto:<EMAIL>"><EMAIL></a>><br>
Dear Rob,</p>
<p>Thank you for supporting my position here ("However, I agree that there are many useful properties that are best specified using more general quantification over types.").</p>
<p>Let me remind you that you pointed out some time ago the fact that the implicit universal quantification over the free type variables in HOL make certain expressions unworkable, namely that the appeal to the axiom of choice can't be made explicit in the form AC => THM because of the free type variable in the hypoth
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| html | 1 | <html>
<head><meta charset="utf-8"><title>[isabelle] Another limitation of HOL: Binding the type va... · Mirror: Isabelle Users Mailing List · Zulip Chat Archive</title></head>
<h2>Stream: <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/index.html">Mirror: Isabelle Users Mailing List</a></h2>
<h3>Topic: <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/topic/.5Bisabelle.5D.20Another.20limitation.20of.20HOL.3A.20Binding.20the.20type.20va.2E.2E.2E.html">[isabelle] Another limitation of HOL: Binding the type va...</a></h3>
<hr>
<base href="https://isabelle.zulipchat.com/">
<head><link href="http://isabelle.systems/zulip-archive/style.css" rel="stylesheet"></head>
<a name="322160390"></a>
<h4><a href="https://isabelle.zulipchat.com/#narrow/stream/247541-Mirror%3A%20Isabelle%20Users%20Mailing%20List/topic/%5Bisabelle%5D%20Another%20limitation%20of%20HOL%3A%20Binding%20the%20type%20va.../near/322160390" class="zl"><img src="http://isabelle.systems/zulip-archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Email Gateway <a href="http://isabelle.systems/zulip-archive/stream/247541-Mirror.3A-Isabelle-Users-Mailing-List/topic/.5Bisabelle.5D.20Another.20limitation.20of.20HOL.3A.20Binding.20the.20type.20va.2E.2E.2E.html#322160390">(Jan 18 2023 at 21:50)</a>:</h4>
<p>From: <NAME> <<a href="mailto:<EMAIL>"><EMAIL></a>><br>
Dear Rob,</p>
<p>Thank you for supporting my position here ("However, I agree that there are many useful properties that are best specified using more general quantification over types.").</p>
<p>Let me remind you that you pointed out some time ago the fact that the implicit universal quantification over the free type variables in HOL make certain expressions unworkable, namely that the appeal to the axiom of choice can't be made explicit in the form AC => THM because of the free type variable in the hypothesis: <a href="https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2018-03/msg00043.html">https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2018-03/msg00043.html</a></p>
<p>With quantification over types this is possible (since the type variable isn't free anymore): <a href="https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2018-03/msg00051.html">https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2018-03/msg00051.html</a><br>
The proof is still available online: <a href="https://www.kenkubota.de/files/ac_instantiation.r0.out.pdf">https://www.kenkubota.de/files/ac_instantiation.r0.out.pdf</a></p>
<p>Note that the Quantified Axiom of Choice (without a free type variable)<br>
∀τ[λt.AC]o<br>
(wff 1388 = QAC)<br>
is to be read as<br>
∀ t . AC<br>
where "t" is the type variable in question here.</p>
<p>Regards,</p>
<p>Ken</p>
<hr>
<p><NAME><br>
<a href="https://doi.org/10.4444/100">https://doi.org/10.4444/100</a></p>
<p>Full thread: <a href="https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2023-01/msg00039.html">https://lists.cam.ac.uk/sympa/arc/cl-isabelle-users/2023-01/msg00039.html</a></p>
<hr><p>Last updated: Sep 01 2023 at 04:17 UTC</p>
</html> |
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// Seqlist.h
// 线性表
//
// Created by 陆敏 on 2018/3/28.
// Copyright © 2018年 Lumin. All rights reserved.
//
#ifndef Seqlist_h
#define Seqlist_h
#include <stdio.h>
#define LENGTH 100
//给一个现有[类型]取别名
typedef int dataType;
typedef struct {
dataType dataArray[LENGTH];//存放顺序表的所有数据
int nLength; //记录当前顺序表的长度
} SeqList;
void initList(SeqList* myList);//初始化操作
int listLength(SeqList myList);//求长度
void insertNode(SeqList* myList,int index,dataType data);//插入数据项
dataType getNodeWithIndex(SeqList myList,int index);//获取某位置的数据项
int getIndexWithNode(SeqList myList,dataType data);//根据数据获取其在顺序表中的位置
//typedef int* pInt;
//struct SeqList{
// dataType dataArray[100];//存放顺序表的所有数据
// int nLength; //记录当前顺序表的长度
//};
//typedef struct SeqList{
// dataType dataArray[100];//存放顺序表的所有数据
// int nLength; //记录当前顺序表的长度
//} mySeqList;
#endif /* Seqlist_h */
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 2 | //
// Seqlist.h
// 线性表
//
// Created by 陆敏 on 2018/3/28.
// Copyright © 2018年 Lumin. All rights reserved.
//
#ifndef Seqlist_h
#define Seqlist_h
#include <stdio.h>
#define LENGTH 100
//给一个现有[类型]取别名
typedef int dataType;
typedef struct {
dataType dataArray[LENGTH];//存放顺序表的所有数据
int nLength; //记录当前顺序表的长度
} SeqList;
void initList(SeqList* myList);//初始化操作
int listLength(SeqList myList);//求长度
void insertNode(SeqList* myList,int index,dataType data);//插入数据项
dataType getNodeWithIndex(SeqList myList,int index);//获取某位置的数据项
int getIndexWithNode(SeqList myList,dataType data);//根据数据获取其在顺序表中的位置
//typedef int* pInt;
//struct SeqList{
// dataType dataArray[100];//存放顺序表的所有数据
// int nLength; //记录当前顺序表的长度
//};
//typedef struct SeqList{
// dataType dataArray[100];//存放顺序表的所有数据
// int nLength; //记录当前顺序表的长度
//} mySeqList;
#endif /* Seqlist_h */
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace App\Services;
require_once dirname(dirname(__FILE__)) . '/Thirdparty/aes-sample/wxBizDataCrypt.php';
/**
* 业务 前台微信类
* User: Administrator
* Date: 2016/7/13
* Time: 10:12
*/
class ServiceAppWeixin extends BaseService
{
/**
* 解析用户信息
* @param $appId
* @param $sessionKey
* @param $encryptedData
* @param $iv
* @return bool|mixed
*/
static function parseUserInfo($appId, $sessionKey, $encryptedData, $iv)
{
$pc = new \WXBizDataCrypt($appId, $sessionKey);
$errCode = $pc->decryptData($encryptedData, $iv, $data);
if ($errCode == 0) {
return json_decode($data);
} else {
return false;
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 | <?php
namespace App\Services;
require_once dirname(dirname(__FILE__)) . '/Thirdparty/aes-sample/wxBizDataCrypt.php';
/**
* 业务 前台微信类
* User: Administrator
* Date: 2016/7/13
* Time: 10:12
*/
class ServiceAppWeixin extends BaseService
{
/**
* 解析用户信息
* @param $appId
* @param $sessionKey
* @param $encryptedData
* @param $iv
* @return bool|mixed
*/
static function parseUserInfo($appId, $sessionKey, $encryptedData, $iv)
{
$pc = new \WXBizDataCrypt($appId, $sessionKey);
$errCode = $pc->decryptData($encryptedData, $iv, $data);
if ($errCode == 0) {
return json_decode($data);
} else {
return false;
}
}
}
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { Component, OnInit } from '@angular/core';
import { LocationStrategy, PlatformLocation, Location } from '@angular/common';
import {User} from "../classes/user";
import {Vendor} from "../classes/vendor";
import {DataService} from "../services/data.service";
@Component({
selector: 'app-home',
templateUrl: './home.component.html',
styleUrls: ['./home.component.scss']
})
export class HomeComponent implements OnInit {
public statsChartType: string;
public statsChartData: any;
public hoursChartType: string;
public hoursChartData: any;
public hoursChartOptions: any;
public hoursChartResponsive: any[];
public activityChartType: string;
public activityChartData: any;
public activityChartOptions: any;
public activityChartResponsive: any[];
local_users: User[];
local_vendors: Vendor[];
public chartLabels:string[] = ['Scans', 'Favourties'];
public chartData:number[] = [6605, 5881];
public type:string = 'pie';
public chartOptions:any = {
responsive: true
};
public lineChartData:Array<any> = [
{data: [2, 59, 80, 60, 76, 60, 0], label: 'Favourites'},
{data: [5, 65, 100, 160, 86, 80, 0], label: 'Scans'},
{data: [0, 10, 30, 50, 17, 12, 0], label: 'Notes'}
];
public lineChartLabels:Array<any> = ['06:00', '08:00', '12:00', '14:00', '16:00', '18:00', '20:00'];
public lineChartOptions:any = {
responsive: true
};
public lineChartColors:Array<any> = [
{ // red
backgroundColor: 'rgba(244,67,54,0.2)',
borderColor: 'rgba(244,67,54,1)',
pointBackgroundColor: 'rgba(244,67,54,1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderColor: 'rgba(244,67,54,0.8)'
},
{ // blue
backgroundColor: 'rgba(33,150,243,0.2)',
borderColor: 'rgba(33,150,243,1)',
pointBackgroundColor: 'rgba(33,150,243,1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderCo
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 1 | import { Component, OnInit } from '@angular/core';
import { LocationStrategy, PlatformLocation, Location } from '@angular/common';
import {User} from "../classes/user";
import {Vendor} from "../classes/vendor";
import {DataService} from "../services/data.service";
@Component({
selector: 'app-home',
templateUrl: './home.component.html',
styleUrls: ['./home.component.scss']
})
export class HomeComponent implements OnInit {
public statsChartType: string;
public statsChartData: any;
public hoursChartType: string;
public hoursChartData: any;
public hoursChartOptions: any;
public hoursChartResponsive: any[];
public activityChartType: string;
public activityChartData: any;
public activityChartOptions: any;
public activityChartResponsive: any[];
local_users: User[];
local_vendors: Vendor[];
public chartLabels:string[] = ['Scans', 'Favourties'];
public chartData:number[] = [6605, 5881];
public type:string = 'pie';
public chartOptions:any = {
responsive: true
};
public lineChartData:Array<any> = [
{data: [2, 59, 80, 60, 76, 60, 0], label: 'Favourites'},
{data: [5, 65, 100, 160, 86, 80, 0], label: 'Scans'},
{data: [0, 10, 30, 50, 17, 12, 0], label: 'Notes'}
];
public lineChartLabels:Array<any> = ['06:00', '08:00', '12:00', '14:00', '16:00', '18:00', '20:00'];
public lineChartOptions:any = {
responsive: true
};
public lineChartColors:Array<any> = [
{ // red
backgroundColor: 'rgba(244,67,54,0.2)',
borderColor: 'rgba(244,67,54,1)',
pointBackgroundColor: 'rgba(244,67,54,1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderColor: 'rgba(244,67,54,0.8)'
},
{ // blue
backgroundColor: 'rgba(33,150,243,0.2)',
borderColor: 'rgba(33,150,243,1)',
pointBackgroundColor: 'rgba(33,150,243,1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderColor: 'rgba(33,150,243,0.8)'
},
{ // yellow
backgroundColor: 'rgba(255, 235, 59,0.2)',
borderColor: 'rgba(255, 235, 59,1)',
pointBackgroundColor: 'rgba(255, 235, 59,1)',
pointBorderColor: '#fff',
pointHoverBackgroundColor: '#fff',
pointHoverBorderColor: 'rgba(255, 235, 59,0.8)'
}
];
public lineChartLegend:boolean = true;
public lineChartType:string = 'line';
// events
public barChartOptions:any = {
scaleShowVerticalLines: false,
responsive: true
};
public barChartLabels:string[] = ['06:00', '08:00', '12:00', '14:00', '16:00', '18:00', '20:00'];
public barChartType:string = 'bar';
public barChartLegend:boolean = true;
public barChartData:any[] = [
{data: [0, 50, 100, 110, 66, 10, 50, 20], label: 'Users'},
{data: [0, 28, 38, 20, 16, 46, 27, 50], label: 'Vendors'}
];
public barChartColors:Array<any> = [
{ // green
backgroundColor: '#4caf50',
borderColor: '#4caf50',
},
{ // purple
backgroundColor: '#9c27b0',
borderColor: '#9c27b0',
}
];
total_user_count: number = 699;
total_vendor_count: number = 142;
total_user_scans: number = 6605;
total_user_favs: number = 5881;
average_scans: number = 9;
average_contacts: number = 47;
constructor(public data: DataService) {
this.type = 'pie';
// this.chartData = {
// labels: ["Scans", "Favourites"],
// datasets: [
// {
// label: "Activity Analysis",
// data: [50, 50],
// backgroundColor: [
// 'rgba(54, 162, 235, 0.2)',
// 'rgba(255, 99, 132, 0.2)'
// // 'rgba(255, 206, 86, 0.2)',
// // 'rgba(75, 192, 192, 0.2)',
// // 'rgba(153, 102, 255, 0.2)',
// // 'rgba(255, 159, 64, 0.2)'
// ],
// borderColor: [
// 'rgba(54, 162, 235, 1)',
// 'rgba(255,99,132,1)'
// // 'rgba(255, 206, 86, 1)',
// // 'rgba(75, 192, 192, 1)',
// // 'rgba(153, 102, 255, 1)',
// // 'rgba(255, 159, 64, 1)'
// ],
// }
// ]
// };
this.hoursChartType = "line";
this.hoursChartOptions = {
responsive: true,
maintainAspectRatio: false
};
data.getUsers().then(users => {
this.local_users = users;
return data.getVendors();
}).then(vendors => {
this.local_vendors = vendors;
this.total_user_count = this.calculateTotalUsers();
this.total_vendor_count = this.calculateTotalVendors();
this.total_user_scans = this.calculateTotalScans();
this.total_user_favs = this.calculateTotalFavs();
this.recalcChartStats();
data.vendors_event.subscribe(vendors => {
this.local_vendors = vendors;
this.total_vendor_count = this.calculateTotalVendors();
this.recalcChartStats();
});
data.users_event.subscribe(users => {
this.local_users = users;
this.total_user_count = this.calculateTotalUsers();
this.total_user_scans = this.calculateTotalScans();
this.total_user_favs = this.calculateTotalFavs();
});
}).catch(ex => {
console.log(ex);
});
}
ngOnInit() {
// this.chartData = {
// labels: ["Scans", "Favourites"],
// datasets: [
// {
// label: "Activity Analysis",
// data: [0,0],
// backgroundColor: [
// 'rgba(54, 162, 235, 0.2)',
// 'rgba(255, 99, 132, 0.2)'
// ],
// borderColor: [
// 'rgba(54, 162, 235, 1)',
// 'rgba(255,99,132,1)'
// ],
// }
// ]};
// this.hoursChartType = ChartType.Line;
// this.hoursChartData = {
// labels: ['9:00AM', '12:00AM', '3:00PM', '6:00PM', '9:00PM', '12:00PM', '3:00AM', '6:00AM'],
// series: [
// [287, 385, 490, 492, 554, 586, 698, 695, 752, 788, 846, 944],
// [67, 152, 143, 240, 287, 335, 435, 437, 539, 542, 544, 647],
// [23, 113, 67, 108, 190, 239, 307, 308, 439, 410, 410, 509]
// ]
// };
// this.hoursChartOptions = {
// low: 0,
// high: 800,
// showArea: true,
// height: '245px',
// axisX: {
// showGrid: false,
// },
// lineSmooth: Chartist.Interpolation.simple({
// divisor: 3
// }),
// showLine: false,
// showPoint: false,
// };
// this.hoursChartResponsive = [
// ['screen and (max-width: 640px)', {
// axisX: {
// labelInterpolationFnc: function (value) {
// return value[0];
// }
// }
// }]
// ];
// this.hoursChartLegendItems = [
// { title: 'Scan', imageClass: 'fa fa-circle text-info' },
// { title: 'Favourite', imageClass: 'fa fa-circle text-danger' },
// { title: 'Add Note', imageClass: 'fa fa-circle text-warning' }
// ];
// this.statsChartType = ChartType.Pie;
// this.statsChartData = {
// labels: ["50", "50"],
// series: [50, 50]
// };
// this.statsChartLegendItems = [
// { title: 'Users', imageClass: 'fa fa-circle text-info' },
// { title: 'Vendors', imageClass: 'fa fa-circle text-danger' },
// ];
this.data.getUsers().then(users => {
this.local_users = users;
return this.data.getVendors();
}).then(vendors => {
this.local_vendors = vendors;
this.total_user_count = this.calculateTotalUsers();
this.total_vendor_count = this.calculateTotalVendors();
this.total_user_scans = this.calculateTotalScans();
this.statsChartData = {
labels: [this.total_user_count + "", this.total_user_count + ""],
series: [50, 50]
};
}).catch(ex => {
console.log(ex);
});
// this.activityChartType = ChartType.Bar;
// this.activityChartData = {
// labels: ['Jan', 'Feb', 'Mar', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
// series: [
// [542, 443, 320, 780, 553, 453, 326, 434, 568, 610, 756, 895],
// [412, 243, 280, 580, 453, 353, 300, 364, 368, 410, 636, 695]
// ]
// };
// this.activityChartOptions = {
// seriesBarDistance: 10,
// axisX: {
// showGrid: false
// },
// height: '245px'
// };
// this.activityChartResponsive = [
// ['screen and (max-width: 640px)', {
// seriesBarDistance: 5,
// axisX: {
// labelInterpolationFnc: function (value) {
// return value[0];
// }
// }
// }]
// ];
// this.activityChartLegendItems = [
// { title: 'Tesla Model S', imageClass: 'fa fa-circle text-info' },
// { title: 'BMW 5 Series', imageClass: 'fa fa-circle text-danger' }
// ];
}
calculateTotalUsers(): number {
let count = 0;
for (let user of this.local_users) {
count++;
}
return count;
}
calculateTotalVendors(): number {
let count = 0;
for (let vendor of this.local_vendors) {
count++;
}
return count;
}
calculateTotalScans(): number {
let count = 0;
for (let user of this.local_users) {
let scans = user.scannedItems;
count += scans.length;
}
this.average_scans = Math.round(count / this.local_users.length);
this.average_contacts = Math.round(count / this.local_vendors.length);
return count;
}
calculateTotalFavs(): number {
let count = 0;
for (let user of this.local_users) {
let favs = user.Favourites;
count += favs.length;
}
return count;
}
recalcChartStats() {
// this.chartData.datasets[0].data.pop();
this.chartData = [this.total_user_scans, this.total_user_favs];
// this.chartData.datasets[0].data = [this.total_user_scans, this.total_user_favs];
// this.chartData.datasets[0].data.push(this.total_user_scans);
// this.chartData.datasets[0].data.push(this.total_user_favs);
// this.chartData.datasets[0].data.push();
// this.statsChartData.series.pop();
// this.statsChartData.series.pop();
// this.statsChartData.series.push(this.total_user_count);
// this.statsChartData.series.push(this.total_vendor_count);
// this.statsChartData.labels.pop();
// this.statsChartData.labels.pop();
// this.statsChartData.labels.push(this.total_user_count);
// this.statsChartData.labels.push(this.total_vendor_count);
}
}
|
Below is an extract from a Swift program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Swift code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Swift concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., protocols, extensions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Swift. It should be similar to a school exercise, a tutorial, or a Swift course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Swift. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// BMKLocationManager.swift
// PaiBaoTang
//
// Created by 茶古电子商务 on 2017/10/11.
// Copyright © 2017年 Z_JaDe. All rights reserved.
//
import Foundation
import ThirdSDK
import Extension
import RxSwift
public class BMKLocationManager:NSObject {
public static let shared:BMKLocationManager = BMKLocationManager()
private override init() {
super.init()
}
private var observeObjectCount:Int = 0
// MARK: 反编码 坐标转地址
var searcherArr:[BMKGeoCodeSearch] = [BMKGeoCodeSearch]()
private lazy var reverseGeoCodeSubject = PublishSubject<(BMKGeoCodeSearch,AddressComponentModel)>()
// MARK: 定位
lazy var locationService = BMKLocationService()
private lazy var locationSubject = ReplaySubject<BMKUserLocation>.create(bufferSize: 1)
private var isCheckCanLocation:Bool = false
}
// MARK: - 反编码 坐标转地址
public extension BMKLocationManager {
public func locationAndReverseGeoCode() -> Observable<AddressComponentModel> {
return self.getLocation().flatMap {[unowned self] (userLocation) -> Observable<AddressComponentModel> in
let coordinate = userLocation.location.coordinate
return self.reverseGeoCode(coordinate)
}
}
public func reverseGeoCode(_ coordinate:CLLocationCoordinate2D) -> Observable<AddressComponentModel> {
let searcher = self.beginSearch(coordinate)
return self.reverseGeoCodeSubject
.filter{$0.0 == searcher}
.take(1)
.map{$0.1}
.do( onDispose: {[unowned self] in
self.endSearch(searcher)
})
}
private func beginSearch(_ coordinate:CLLocationCoordinate2D) -> BMKGeoCodeSearch {
let searcher = BMKGeoCodeSearch()
searcher.delegate = self
let result = BMKReverseGeoCodeOption()
result.reverseGeoPoint = coordinate
if searcher.reverseGeoCode(result) == false {
self.reverseGeoCodeSubject.onError(NSError(domain: "反geo检索失败", code: -1, userInfo: nil))
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| swift | 2 | //
// BMKLocationManager.swift
// PaiBaoTang
//
// Created by 茶古电子商务 on 2017/10/11.
// Copyright © 2017年 Z_JaDe. All rights reserved.
//
import Foundation
import ThirdSDK
import Extension
import RxSwift
public class BMKLocationManager:NSObject {
public static let shared:BMKLocationManager = BMKLocationManager()
private override init() {
super.init()
}
private var observeObjectCount:Int = 0
// MARK: 反编码 坐标转地址
var searcherArr:[BMKGeoCodeSearch] = [BMKGeoCodeSearch]()
private lazy var reverseGeoCodeSubject = PublishSubject<(BMKGeoCodeSearch,AddressComponentModel)>()
// MARK: 定位
lazy var locationService = BMKLocationService()
private lazy var locationSubject = ReplaySubject<BMKUserLocation>.create(bufferSize: 1)
private var isCheckCanLocation:Bool = false
}
// MARK: - 反编码 坐标转地址
public extension BMKLocationManager {
public func locationAndReverseGeoCode() -> Observable<AddressComponentModel> {
return self.getLocation().flatMap {[unowned self] (userLocation) -> Observable<AddressComponentModel> in
let coordinate = userLocation.location.coordinate
return self.reverseGeoCode(coordinate)
}
}
public func reverseGeoCode(_ coordinate:CLLocationCoordinate2D) -> Observable<AddressComponentModel> {
let searcher = self.beginSearch(coordinate)
return self.reverseGeoCodeSubject
.filter{$0.0 == searcher}
.take(1)
.map{$0.1}
.do( onDispose: {[unowned self] in
self.endSearch(searcher)
})
}
private func beginSearch(_ coordinate:CLLocationCoordinate2D) -> BMKGeoCodeSearch {
let searcher = BMKGeoCodeSearch()
searcher.delegate = self
let result = BMKReverseGeoCodeOption()
result.reverseGeoPoint = coordinate
if searcher.reverseGeoCode(result) == false {
self.reverseGeoCodeSubject.onError(NSError(domain: "反geo检索失败", code: -1, userInfo: nil))
logError("反geo检索发送失败")
}
self.searcherArr.append(searcher)
return searcher
}
public func endSearch(_ searcher:BMKGeoCodeSearch) {
searcher.delegate = nil
self.searcherArr.remove(searcher)
}
}
// MARK: - 反编码 坐标转地址 BMKGeoCodeSearchDelegate
extension BMKLocationManager:BMKGeoCodeSearchDelegate {
/// ZJaDe: 地址信息搜索结果
public func onGetGeoCodeResult(_ searcher: BMKGeoCodeSearch!, result: BMKGeoCodeResult!, errorCode error: BMKSearchErrorCode) {
}
/// ZJaDe: 返回反地理编码搜索结果
public func onGetReverseGeoCodeResult(_ searcher: BMKGeoCodeSearch!, result: BMKReverseGeoCodeResult!, errorCode error: BMKSearchErrorCode) {
guard let result = result else {
return
}
if result.address != nil, result.address.count > 0 {
var addressModel = AddressComponentModel()
addressModel.sematicDescription = result.sematicDescription
addressModel.businessCircle = result.businessCircle
addressModel.province = result.addressDetail.province
addressModel.city = result.addressDetail.city
addressModel.area = result.addressDetail.district
addressModel.address = result.addressDetail.streetName + result.addressDetail.streetNumber
addressModel.coordinate = result.location
self.reverseGeoCodeSubject.onNext((searcher,addressModel))
}else if (error != BMK_SEARCH_NO_ERROR) {
HUD.showError("反编码错误->\(error)")
}
}
}
// MARK: - 定位
extension BMKLocationManager {
public func getLocation() -> Observable<BMKUserLocation> {
return self.beginLocation().take(1)
}
// MARK: 开启定位同时验证
public func beginLocation() -> Observable<BMKUserLocation> {
let observable = Observable<()>.create {[unowned self] (observer) in
self.checkCanLocation { (canLocation) in
if canLocation {
self.startUserLocationService()
observer.onNext(())
}else {
observer.onError(NSError())
}
}
return Disposables.create()
}.flatMap{self.locationSubject.retry(3)}
return endLocationWhenDispose(observable).do(onError: { (error) in
HUD.showError("定位出现错误")
})
}
// MARK: 只请求定位，不提示错误
public func getLocationIfCan() -> Observable<BMKUserLocation> {
return self.onlyLocation().take(1)
}
public func onlyLocation() -> Observable<BMKUserLocation> {
self.startUserLocationService()
return endLocationWhenDispose(self.locationSubject.retry(3))
}
// MARK: 停止定位
public func endLocation() {
self.stopUserLocationService()
}
}
extension BMKLocationManager {
private func endLocationWhenDispose(_ observable:Observable<BMKUserLocation>) -> Observable<BMKUserLocation> {
return observable.do(onDispose: { [unowned self] in
self.endLocation()
})
}
}
extension BMKLocationManager {
private func startUserLocationService() {
self.observeObjectCount += 1
if self.locationService.delegate == nil {
self.locationService.delegate = self
self.locationService.startUserLocationService()
}
}
private func stopUserLocationService() {
if self.observeObjectCount > 1 {
self.observeObjectCount -= 1
}else {
self.observeObjectCount = 0
self.locationService.stopUserLocationService()
self.locationService.delegate = nil
}
}
private func checkCanLocation(_ closure:@escaping (Bool)->()) {
guard self.isCheckCanLocation == false else {
return
}
self.isCheckCanLocation = true
let pscope = PermissionScope()
pscope.addPermission(LocationWhileInUsePermission(), message: "如果拒绝将无法使用定位功能")
pscope.bodyLabel.text = "在您定位之前，app需要获取\r\niPhone的定位权限"
pscope.show({ (finished, results) in
self.isCheckCanLocation = false
closure(true)
}, cancelled: {(results) in
self.isCheckCanLocation = false
closure(false)
})
}
// MARK: 更新定位
private func updateLocation(_ userLocation:BMKUserLocation) {
if userLocation.location != nil {
self.locationSubject.onNext(userLocation)
}
}
}
// MARK: - 定位 BMKLocationServiceDelegate
extension BMKLocationManager:BMKLocationServiceDelegate {
public func willStartLocatingUser() {
logInfo("开始定位")
}
public func didStopLocatingUser() {
logInfo("停止定位")
}
public func didUpdate(_ userLocation: BMKUserLocation!) {
updateLocation(userLocation)
}
public func didUpdateUserHeading(_ userLocation: BMKUserLocation!) {
updateLocation(userLocation)
}
public func didFailToLocateUserWithError(_ error: Error!) {
self.locationSubject.onError(error)
}
}
|
Below is an extract from a C++ program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C++ code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C++ concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., memory management). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C++. It should be similar to a school exercise, a tutorial, or a C++ course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C++. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#include <cstdio>
#include <algorithm>
#include <map>
using namespace std;
struct P {
double first;
int second;
};
class great {
public:
bool operator()(const P& a, const P& b) {
return a.first<b.first;
}
};
P team1[8], team2[8], team3[8];
P amari[18];
int main() {
for (int i=0; i<8; i++)
scanf("%d%lf",&team1[i].second,&team1[i].first);
for (int i=0; i<8; i++)
scanf("%d%lf",&team2[i].second,&team2[i].first);
for (int i=0; i<8; i++)
scanf("%d%lf",&team3[i].second,&team3[i].first);
sort(team1, team1+8, great());
sort(team2, team2+8, great());
sort(team3, team3+8, great());
for (int i=2; i<8; i++) amari[i-2]=team1[i];
for (int i=2; i<8; i++) amari[i+4]=team2[i];
for (int i=2; i<8; i++) amari[i+10]=team3[i];
sort(amari, amari+18, great());
printf("%d %.2lf\n%d %.2lf\n",team1[0].second,team1[0].first,
team1[1].second,team1[1].first);
printf("%d %.2lf\n%d %.2lf\n",team2[0].second,team2[0].first,
team2[1].second,team2[1].first);
printf("%d %.2lf\n%d %.2lf\n",team3[0].second,team3[0].first,
team3[1].second,team3[1].first);
printf("%d %.2lf\n%d %.2lf\n",amari[0].second,amari[0].first,
amari[1].second,amari[1].first);
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| cpp | 2 | #include <cstdio>
#include <algorithm>
#include <map>
using namespace std;
struct P {
double first;
int second;
};
class great {
public:
bool operator()(const P& a, const P& b) {
return a.first<b.first;
}
};
P team1[8], team2[8], team3[8];
P amari[18];
int main() {
for (int i=0; i<8; i++)
scanf("%d%lf",&team1[i].second,&team1[i].first);
for (int i=0; i<8; i++)
scanf("%d%lf",&team2[i].second,&team2[i].first);
for (int i=0; i<8; i++)
scanf("%d%lf",&team3[i].second,&team3[i].first);
sort(team1, team1+8, great());
sort(team2, team2+8, great());
sort(team3, team3+8, great());
for (int i=2; i<8; i++) amari[i-2]=team1[i];
for (int i=2; i<8; i++) amari[i+4]=team2[i];
for (int i=2; i<8; i++) amari[i+10]=team3[i];
sort(amari, amari+18, great());
printf("%d %.2lf\n%d %.2lf\n",team1[0].second,team1[0].first,
team1[1].second,team1[1].first);
printf("%d %.2lf\n%d %.2lf\n",team2[0].second,team2[0].first,
team2[1].second,team2[1].first);
printf("%d %.2lf\n%d %.2lf\n",team3[0].second,team3[0].first,
team3[1].second,team3[1].first);
printf("%d %.2lf\n%d %.2lf\n",amari[0].second,amari[0].first,
amari[1].second,amari[1].first);
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import styled from "styled-components";
const Container = styled.div`
@media (min-width: 1340px) {
max-width: 1260px;
}
margin-left: auto;
margin-right: auto;
padding: 0px 30px;
margin-bottom: 80px;
width: ${({ width }) => width || "100%"};
margin-top: 100px;
`;
export default Container;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import styled from "styled-components";
const Container = styled.div`
@media (min-width: 1340px) {
max-width: 1260px;
}
margin-left: auto;
margin-right: auto;
padding: 0px 30px;
margin-bottom: 80px;
width: ${({ width }) => width || "100%"};
margin-top: 100px;
`;
export default Container;
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace Base\AdminBundle\Controller;
use Sonata\AdminBundle\Controller\CRUDController;
class CorpoFestivalHistoryAdminController extends CRUDController
{
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 1 | <?php
namespace Base\AdminBundle\Controller;
use Sonata\AdminBundle\Controller\CRUDController;
class CorpoFestivalHistoryAdminController extends CRUDController
{
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { combineReducers, createStore } from 'redux';
import reducer from '../Reducers/MovieList-reducer';
const allReducer = combineReducers ({
movies: reducer
})
export const store = createStore(
allReducer,
window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__()
)
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import { combineReducers, createStore } from 'redux';
import reducer from '../Reducers/MovieList-reducer';
const allReducer = combineReducers ({
movies: reducer
})
export const store = createStore(
allReducer,
window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__()
) |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
export function update() {
navigator.geolocation.getCurrentPosition(
(position) => {
// console.log(`received current position ${JSON.stringify(position)}`);
// Store.setLocation({latitude: position.coords.latitude, longitude: position.coords.longitude});
},
(error) => console.log('Error from geolocation.getCurrentPosition '+error.message),
{enableHighAccuracy: true, timeout: 20000, maximumAge: 1000}
);
}
export default {
update
};
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 |
export function update() {
navigator.geolocation.getCurrentPosition(
(position) => {
// console.log(`received current position ${JSON.stringify(position)}`);
// Store.setLocation({latitude: position.coords.latitude, longitude: position.coords.longitude});
},
(error) => console.log('Error from geolocation.getCurrentPosition '+error.message),
{enableHighAccuracy: true, timeout: 20000, maximumAge: 1000}
);
}
export default {
update
};
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
* Copyright (c) <NAME> 2017
*/
package de.dytanic.cloudnet.event.interfaces;
import de.dytanic.cloudnet.event.Event;
import de.dytanic.cloudnet.event.EventKey;
import de.dytanic.cloudnet.event.IEventListener;
public interface IEventManager {
<T extends Event> void registerListener(EventKey eventKey, IEventListener<T> eventListener);
<T extends Event> void registerListeners(EventKey eventKey, IEventListener<T>... eventListeners);
void unregisterListener(EventKey eventKey);
void unregisterListener(IEventListener<?> eventListener);
void unregisterListener(Class<? extends Event> eventClass);
<T extends Event> boolean callEvent(T event);
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 1 | /*
* Copyright (c) <NAME> 2017
*/
package de.dytanic.cloudnet.event.interfaces;
import de.dytanic.cloudnet.event.Event;
import de.dytanic.cloudnet.event.EventKey;
import de.dytanic.cloudnet.event.IEventListener;
public interface IEventManager {
<T extends Event> void registerListener(EventKey eventKey, IEventListener<T> eventListener);
<T extends Event> void registerListeners(EventKey eventKey, IEventListener<T>... eventListeners);
void unregisterListener(EventKey eventKey);
void unregisterListener(IEventListener<?> eventListener);
void unregisterListener(Class<? extends Event> eventClass);
<T extends Event> boolean callEvent(T event);
} |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import React from "react";
export default function QuestionPanel(props) {
const { currentIndex, questionTracker } = props;
console.log(questionTracker);
const listItems = questionTracker.map((question, index) => {
//current question
if (question === "" && index === currentIndex) {
return (
<li
style={{
fontWeight: "bold",
background: "#f57b02",
borderRadius: "3px",
width: "100px",
}}
>
<div style={{ width: "37px", textAlign: "right", color: "white" }}>
{index + 1}:
</div>
</li>
);
} else if (question === "") {
// blank
return (
<li style={{ width: "100px" }}>
<div style={{ color: "#fff", width: "100%" }}>
<div style={{ width: "37px", textAlign: "right" }}>
{index + 1}:
</div>
<div
style={{
width: "100%",
textAlign: "center",
color: "rgba(255, 0, 0, 0.85)",
}}
></div>
</div>
</li>
);
} else if (question === "X") {
// incorrect answer
return (
<li style={{ width: "100px" }}>
<div
style={{
height: "27px",
color: "#fff",
width: "100%",
display: "flex",
alignItems: "center",
}}
>
<div
style={{
width: "37px",
textAlign: "right",
alignItems: "center",
}}
>
{index + 1}:
</div>
<div
style={{
lineHeight: "24px",
height: "24px",
flex: "1",
textAlign: "center",
color: "rgba(255, 0, 0, 0.85)",
}}
>
❌
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import React from "react";
export default function QuestionPanel(props) {
const { currentIndex, questionTracker } = props;
console.log(questionTracker);
const listItems = questionTracker.map((question, index) => {
//current question
if (question === "" && index === currentIndex) {
return (
<li
style={{
fontWeight: "bold",
background: "#f57b02",
borderRadius: "3px",
width: "100px",
}}
>
<div style={{ width: "37px", textAlign: "right", color: "white" }}>
{index + 1}:
</div>
</li>
);
} else if (question === "") {
// blank
return (
<li style={{ width: "100px" }}>
<div style={{ color: "#fff", width: "100%" }}>
<div style={{ width: "37px", textAlign: "right" }}>
{index + 1}:
</div>
<div
style={{
width: "100%",
textAlign: "center",
color: "rgba(255, 0, 0, 0.85)",
}}
></div>
</div>
</li>
);
} else if (question === "X") {
// incorrect answer
return (
<li style={{ width: "100px" }}>
<div
style={{
height: "27px",
color: "#fff",
width: "100%",
display: "flex",
alignItems: "center",
}}
>
<div
style={{
width: "37px",
textAlign: "right",
alignItems: "center",
}}
>
{index + 1}:
</div>
<div
style={{
lineHeight: "24px",
height: "24px",
flex: "1",
textAlign: "center",
color: "rgba(255, 0, 0, 0.85)",
}}
>
❌
</div>
</div>
</li>
);
} else {
// correct answer
return (
<li style={{ width: "100px" }}>
<div style={{ color: "#fff", display: "flex", alignItems: "center" }}>
<div style={{ width: "37px", textAlign: "right" }}>
{index + 1}:
</div>
<div
style={{
lineHeight: "27px",
height: "27px",
flex: "1",
textAlign: "center",
color: "rgba(24, 206, 0, 0.85)",
}}
>
{" "}
✔
</div>
</div>
</li>
);
}
});
return (
<div
style={{
fontSize: "24px",
backgroundColor: "rgba(0, 0, 0, 0.80)",
color: "rgba(255, 255, 255, 0.80)",
padding: "1rem",
borderRadius: "10px",
boxShadow: "1px 1px 5px #ebebeb",
margin: "0 2rem 0 Auto ",
}}
>
<ul
className="questionList"
style={{
listStyle: "none",
padding: "0 10px",
display: "flex",
flexDirection: "column-reverse",
width: "120px",
}}
>
{listItems}
</ul>
</div>
);
} |
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
namespace Sitecore.FakeDb.Tests
{
using System;
using System.Linq;
using FluentAssertions;
using Ploeh.AutoFixture.Xunit2;
using Sitecore.Data;
using Sitecore.FakeDb.Security.AccessControl;
using Xunit;
public class DbItemTest
{
[Fact]
public void ShouldGenerateNewIdsIfNotSet()
{
// arrange & act
var item = new DbItem("my item");
// assert
item.ID.IsNull.Should().BeFalse();
}
[Fact]
public void ShouldGenerateNameBasedOnIdIfNotSet()
{
// arrange
var id = ID.NewID;
var item = new DbItem(null, id);
// act & assert
item.Name.Should().Be(id.ToShortID().ToString());
}
[Fact]
public void ShouldCreateNewDbItem()
{
// arrange & act
var item = new DbItem("home");
// assert
item.TemplateID.IsNull.Should().BeTrue();
item.Children.Should().BeEmpty();
item.Fields.Should().BeEmpty();
item.FullPath.Should().BeNull();
item.ParentID.Should().BeNull();
}
[Fact]
public void ShouldAddFieldByNameAndValue()
{
// arrange
var item = new DbItem("home") { { "Title", "Welcome!" } };
// act & assert
item.Fields.Should().ContainSingle(f => f.Name == "Title" && f.Value == "Welcome!");
}
[Fact]
public void ShouldAddFieldByIdAndValue()
{
// arrange
var item = new DbItem("home") { { FieldIDs.Hidden, "1" } };
// act & assert
item.Fields.Should().ContainSingle(f => f.ID == FieldIDs.Hidden && f.Value == "1");
}
[Fact]
public void ShouldCreateItemWithChildrenProvidingName()
{
// arrange
var child = new DbItem("child");
// act
var item = new DbItem("home", child);
// assert
item.Children.Single().Should().BeEquivalentTo(child);
}
[Fact]
public void ShouldCreateItemWithChildrenProvidingNameAndId()
{
// arrange
var child = new DbItem("child");
// act
var item =
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 4 | namespace Sitecore.FakeDb.Tests
{
using System;
using System.Linq;
using FluentAssertions;
using Ploeh.AutoFixture.Xunit2;
using Sitecore.Data;
using Sitecore.FakeDb.Security.AccessControl;
using Xunit;
public class DbItemTest
{
[Fact]
public void ShouldGenerateNewIdsIfNotSet()
{
// arrange & act
var item = new DbItem("my item");
// assert
item.ID.IsNull.Should().BeFalse();
}
[Fact]
public void ShouldGenerateNameBasedOnIdIfNotSet()
{
// arrange
var id = ID.NewID;
var item = new DbItem(null, id);
// act & assert
item.Name.Should().Be(id.ToShortID().ToString());
}
[Fact]
public void ShouldCreateNewDbItem()
{
// arrange & act
var item = new DbItem("home");
// assert
item.TemplateID.IsNull.Should().BeTrue();
item.Children.Should().BeEmpty();
item.Fields.Should().BeEmpty();
item.FullPath.Should().BeNull();
item.ParentID.Should().BeNull();
}
[Fact]
public void ShouldAddFieldByNameAndValue()
{
// arrange
var item = new DbItem("home") { { "Title", "Welcome!" } };
// act & assert
item.Fields.Should().ContainSingle(f => f.Name == "Title" && f.Value == "Welcome!");
}
[Fact]
public void ShouldAddFieldByIdAndValue()
{
// arrange
var item = new DbItem("home") { { FieldIDs.Hidden, "1" } };
// act & assert
item.Fields.Should().ContainSingle(f => f.ID == FieldIDs.Hidden && f.Value == "1");
}
[Fact]
public void ShouldCreateItemWithChildrenProvidingName()
{
// arrange
var child = new DbItem("child");
// act
var item = new DbItem("home", child);
// assert
item.Children.Single().Should().BeEquivalentTo(child);
}
[Fact]
public void ShouldCreateItemWithChildrenProvidingNameAndId()
{
// arrange
var child = new DbItem("child");
// act
var item = new DbItem("home", ID.NewID, child);
// assert
item.Children.Single().Should().BeEquivalentTo(child);
}
[Fact]
public void ShouldCreateItemWithChildrenProvidingNameIdAndTemplateId()
{
// arrange
var child = new DbItem("child");
// act
var item = new DbItem("home", ID.NewID, ID.NewID, child);
// assert
item.Children.Single().Should().BeEquivalentTo(child);
}
[Fact]
public void ShouldCreateItemButNotAddChildrenProvidingNameIdAndTemplateIdIfChildrenObjectIsNull()
{
// arrange
// act
var item = new DbItem("home", ID.NewID, ID.NewID, null);
// assert
item.Children.Count.Should().Be(0);
}
[Fact]
public void ShouldCreateItemButNotAssignChildrenThatAreNotDbItems()
{
// arrange
// act
var item = new DbItem("home", ID.NewID, ID.NewID, null, new object());
// assert
item.Children.Count.Should().Be(0);
}
[Fact]
public void ShouldAddChildItem()
{
// arrange
var parent = new DbItem("parent");
var child = new DbItem("child");
// act
parent.Add(child);
// assert
parent.Children.Single().Should().BeEquivalentTo(child);
}
[Fact]
public void ShouldCreateNewItemAccess()
{
// arrange
var item = new DbItem("home");
// act
item.Access.Should().BeOfType<DbItemAccess>();
}
[Fact]
public void ShouldSetItemAccess()
{
// arrange
var item = new DbItem("home") { Access = new DbItemAccess { CanRead = false } };
// act & assert
item.Access.CanRead.Should().BeFalse();
}
[Theory, AutoData]
public void ShouldThrowIfFieldNameIsNull(DbItem item, string value)
{
// act
Action action = () => item.Add((string)null, value);
// assert
action.ShouldThrow<ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: fieldName");
}
[Theory, AutoData]
public void ShouldThrowIfFieldIdIsNull(DbItem item, string value)
{
// act
Action action = () => item.Add((ID)null, value);
// assert
action.ShouldThrow<ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: fieldId");
}
[Theory, AutoData]
public void ShouldThrowIfFieldIsNull(DbItem item)
{
// act
Action action = () => item.Add((DbField)null);
// assert
action.ShouldThrow<ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: field");
}
[Theory, AutoData]
public void ShouldThrowIChildItemIsNull(DbItem item)
{
// act
Action action = () => item.Add((DbItem)null);
// assert
action.ShouldThrow<ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: child");
}
}
} |
Below is an extract from a C++ program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C++ code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C++ concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., memory management). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C++. It should be similar to a school exercise, a tutorial, or a C++ course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C++. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#include "array.h"
#include <iostream>
using namespace std;
ARRAY::ARRAY(){
size = 10;
arr = new int[size];
for(int i=0; i<size; i++){
arr[i] = i;
}
}
ARRAY::ARRAY(int init_size){
size = init_size;
arr = new int[size];
for(int i=0; i<size; i++){
arr[i] = i;
}
}
ARRAY::~ARRAY(){
delete[] arr;
}
int ARRAY::get_size(){
return size;
}
void ARRAY::print_arr(){
for(int i=0; i<size; i++){
cout << arr[i] << endl;
}
}
int & ARRAY::operator[](int index){
return arr[index];
}
int & ARRAY::front(){
return *arr;
}
int & ARRAY::back(){
return arr[size-1];
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| cpp | 3 | #include "array.h"
#include <iostream>
using namespace std;
ARRAY::ARRAY(){
size = 10;
arr = new int[size];
for(int i=0; i<size; i++){
arr[i] = i;
}
}
ARRAY::ARRAY(int init_size){
size = init_size;
arr = new int[size];
for(int i=0; i<size; i++){
arr[i] = i;
}
}
ARRAY::~ARRAY(){
delete[] arr;
}
int ARRAY::get_size(){
return size;
}
void ARRAY::print_arr(){
for(int i=0; i<size; i++){
cout << arr[i] << endl;
}
}
int & ARRAY::operator[](int index){
return arr[index];
}
int & ARRAY::front(){
return *arr;
}
int & ARRAY::back(){
return arr[size-1];
} |
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs/Rx';
import { DepartamentoProdutoService } from './../../../../-services/-departamento-produto/-departamento-produto.service';
import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
@Injectable()
export class DepartamentoProdutoListagemResolver implements Resolve<any>{
constructor(
private _departamentoProdutoService: DepartamentoProdutoService
){}
resolve(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot
): Observable<any> | Promise<any> | any{
return this._departamentoProdutoService.listarPorContrato();
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 1 | import { Injectable } from '@angular/core';
import { Observable } from 'rxjs/Rx';
import { DepartamentoProdutoService } from './../../../../-services/-departamento-produto/-departamento-produto.service';
import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
@Injectable()
export class DepartamentoProdutoListagemResolver implements Resolve<any>{
constructor(
private _departamentoProdutoService: DepartamentoProdutoService
){}
resolve(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot
): Observable<any> | Promise<any> | any{
return this._departamentoProdutoService.listarPorContrato();
}
} |
Below is an extract from a Kotlin program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Kotlin code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Kotlin concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., coroutines, extension functions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Kotlin. It should be similar to a school exercise, a tutorial, or a Kotlin course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Kotlin. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package com.charmist.movieapp
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.recyclerview.widget.LinearLayoutManager
import kotlinx.android.synthetic.main.activity_main.*
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val adapter = MovieAdapter {
val intent = Intent(this, MovieDetailActivity::class.java)
intent.putExtra("movie", it)
startActivity(intent)
}
rvMovie.apply {
layoutManager =
LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
this.adapter = adapter
}
requestMovieList()
}
fun requestMovieList() {
progressLoading.visibility = View.VISIBLE
Apis.api.getMovie().enqueue(object : Callback<MovieResponse> {
override fun onFailure(call: Call<MovieResponse>, t: Throwable) {
progressLoading.visibility = View.GONE
Toast.makeText(this@MainActivity, t.message.toString(), Toast.LENGTH_SHORT).show()
}
override fun onResponse(call: Call<MovieResponse>, response: Response<MovieResponse>) {
progressLoading.visibility = View.GONE
val movieList = response.body()?.results
(rvMovie.adapter as MovieAdapter).values = movieList ?: emptyList()
}
})
}
fun mockMovie() {
val movieList = mutableListOf(
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| kotlin | 3 | package com.charmist.movieapp
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.recyclerview.widget.LinearLayoutManager
import kotlinx.android.synthetic.main.activity_main.*
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val adapter = MovieAdapter {
val intent = Intent(this, MovieDetailActivity::class.java)
intent.putExtra("movie", it)
startActivity(intent)
}
rvMovie.apply {
layoutManager =
LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
this.adapter = adapter
}
requestMovieList()
}
fun requestMovieList() {
progressLoading.visibility = View.VISIBLE
Apis.api.getMovie().enqueue(object : Callback<MovieResponse> {
override fun onFailure(call: Call<MovieResponse>, t: Throwable) {
progressLoading.visibility = View.GONE
Toast.makeText(this@MainActivity, t.message.toString(), Toast.LENGTH_SHORT).show()
}
override fun onResponse(call: Call<MovieResponse>, response: Response<MovieResponse>) {
progressLoading.visibility = View.GONE
val movieList = response.body()?.results
(rvMovie.adapter as MovieAdapter).values = movieList ?: emptyList()
}
})
}
fun mockMovie() {
val movieList = mutableListOf(
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER2"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER3"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER4"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER5"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER6"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER7"
),
Movie(
1,
"Avenger overview",
"https://lumiere-a.akamaihd.net/v1/images/avengers2-movieposter-web_210f6394.jpeg?region=0%2C0%2C600%2C900",
"3/4/60",
"AVENGER8"
)
)
}
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Anju.Fangke.Client.SDK
{
public enum RentType
{
合租 = 0,
整租 = 1,
}
public enum FeeType
{
计数收费 = 1,
固定收费 = 2,
}
public enum CycleType
{
月 = 1,
季度 = 2,
年 = 3,
}
public enum HouseType
{
托管 = 1,
可租 = 2,
可售 = 3,
我租 = 4,
我售 = 5,
租售 = 6,
已租 = 7,
已售 = 8,
被成交 = 9,
暂缓 = 10
}
public enum DecorationType
{
毛坯 = 1,
简装 = 2,
精装 = 3,
豪装 = 4,
}
public enum DataAccessType
{
所有数据 = 1,
自己及子级数据 = 2,
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 1 | using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Anju.Fangke.Client.SDK
{
public enum RentType
{
合租 = 0,
整租 = 1,
}
public enum FeeType
{
计数收费 = 1,
固定收费 = 2,
}
public enum CycleType
{
月 = 1,
季度 = 2,
年 = 3,
}
public enum HouseType
{
托管 = 1,
可租 = 2,
可售 = 3,
我租 = 4,
我售 = 5,
租售 = 6,
已租 = 7,
已售 = 8,
被成交 = 9,
暂缓 = 10
}
public enum DecorationType
{
毛坯 = 1,
简装 = 2,
精装 = 3,
豪装 = 4,
}
public enum DataAccessType
{
所有数据 = 1,
自己及子级数据 = 2,
}
} |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import React from 'react';
import TitleSerif from '../images/mv_titleSerif@2x.png'
import TitleSub from '../images/mv_titleSub@2x.png'
import FirstTitle from '../images/mv_title01@2x.png';
import SecondTitle from '../images/mv_title02@2x.png';
import foodOne from '../images/mv_img01@2x.png';
import foodTwo from '../images/mv_img02@2x.png';
import foodThree from '../images/mv_img03@2x.png';
import foodFour from '../images/mv_img04@2x.png';
class Mainpage extends React.Component {
render() {
const { styles } = this.props
const mainPageStyle = {
disapear: {
opacity: styles.changePosition ? 0 : 1,
},
bigCircle: {
width: styles.changePosition ? "84vh" : "66.41vw",
height: styles.changePosition ? "84vh" : "66.41vw",
},
smallCircle: {
minWidth: styles.changePosition ? "72vh" : "",
width: styles.changePosition ? "72vh" : "42.32vw",
height: styles.changePosition ? "72vh" : "42.32vw",
},
loop: {
width: styles.changePosition ? "68vh" : "39.72vw",
height: styles.changePosition ? "68vh" : "39.72vw",
top: styles.changePosition ? "2vh" : "7px",
},
title: {
top: styles.changePosition ? "7.7vh" : "0",
margin: styles.changePosition ? "8.6vh 0 0" : "8.6vw 0 0",
},
firstTitle: {
width: styles.changePosition ? "34.56vh" : "23.7vw",
},
secondTitle: {
width: styles.changePosition ? "34.05vh" : "22.79vw",
top: styles.changePosition ? "0.89vh" : "0.14vw",
left: styles.changePosition ? "8.68vh" : "5.47vw",
},
titleSerif: {
width: styles.changePosition ? "5.89vh" : "4.04vw",
top: styles.changePosition ? "16.7vh" : "8.34vw",
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 1 | import React from 'react';
import TitleSerif from '../images/mv_titleSerif@2x.png'
import TitleSub from '../images/mv_titleSub@2x.png'
import FirstTitle from '../images/mv_title01@2x.png';
import SecondTitle from '../images/mv_title02@2x.png';
import foodOne from '../images/mv_img01@2x.png';
import foodTwo from '../images/mv_img02@2x.png';
import foodThree from '../images/mv_img03@2x.png';
import foodFour from '../images/mv_img04@2x.png';
class Mainpage extends React.Component {
render() {
const { styles } = this.props
const mainPageStyle = {
disapear: {
opacity: styles.changePosition ? 0 : 1,
},
bigCircle: {
width: styles.changePosition ? "84vh" : "66.41vw",
height: styles.changePosition ? "84vh" : "66.41vw",
},
smallCircle: {
minWidth: styles.changePosition ? "72vh" : "",
width: styles.changePosition ? "72vh" : "42.32vw",
height: styles.changePosition ? "72vh" : "42.32vw",
},
loop: {
width: styles.changePosition ? "68vh" : "39.72vw",
height: styles.changePosition ? "68vh" : "39.72vw",
top: styles.changePosition ? "2vh" : "7px",
},
title: {
top: styles.changePosition ? "7.7vh" : "0",
margin: styles.changePosition ? "8.6vh 0 0" : "8.6vw 0 0",
},
firstTitle: {
width: styles.changePosition ? "34.56vh" : "23.7vw",
},
secondTitle: {
width: styles.changePosition ? "34.05vh" : "22.79vw",
top: styles.changePosition ? "0.89vh" : "0.14vw",
left: styles.changePosition ? "8.68vh" : "5.47vw",
},
titleSerif: {
width: styles.changePosition ? "5.89vh" : "4.04vw",
top: styles.changePosition ? "16.7vh" : "8.34vw",
left: styles.changePosition ? "11.62vh" : "-28.25vw",
right: styles.changePosition ? "auto" : "0",
},
titleSub: {
width: styles.changePosition ? "27.21vh" : "18.49vw",
top: styles.changePosition ? "8.09vh" : "2.74vw",
},
whale: {
width: styles.changePosition ? "50.3vh" : "40.76vw",
height: styles.changePosition ? "23.09vh" : "19.02vw",
left: styles.changePosition ? "0vh" : "1.83vw",
right: styles.changePosition ? "0vh" : "",
bottom: styles.changePosition ? "-6.61vh" : "-6.11vw",
},
bigWave: {
width: styles.changePosition ? "100%" : "42.32vw",
height: styles.changePosition ? "25vh" : "13.55vw",
top: styles.changePosition ? "27.95vh" : "16.92vw",
},
smallWave: {
width: styles.changePosition ? "100%" : "42.32vw",
height: styles.changePosition ? "13.98vh" : "7.17vw",
top: styles.changePosition ? "30.89vh" : "19.8vw",
},
imageArea: {
width: styles.changePosition ? "72vh" : "66.41vw",
height: styles.changePosition ? "72vh" : "66.41vw",
zIndex: styles.changePosition ? "5" : "3",
},
bottomArea: {
fontSize: styles.changePosition ? "1.77vh" : "0.92vw",
letterSpacing: styles.changePosition ? "0.11em" : "",
},
foodOne: {
width: styles.changePosition ? "12.14vh" : "13.03vw",
height: styles.changePosition ? "12.14vh" : "13.03vw",
top: styles.changePosition ? 'auto' : "8vw",
right: styles.changePosition ? 'auto' : "",
left: styles.changePosition ? '15.45vh' : "10vw",
bottom: styles.changePosition ? '-5.14vh' : "",
},
foodTwo: {
width: styles.changePosition ? "17.65vh" : "19.54vw",
height: styles.changePosition ? "17.65vh" : "19.54vw",
top: styles.changePosition ? 'auto' : "25vw",
right: styles.changePosition ? 'auto' : "",
left: styles.changePosition ? '3.68vh' : "-5vw",
bottom: styles.changePosition ? '0.74vh' : "",
},
circleArea: {
width: styles.changePosition ? "72vh" : "66.41vw",
height: styles.changePosition ? "72vh" : "66.41vw",
},
circleOne: {
width: styles.changePosition ? "14.71vh" : "20.84vw",
height: styles.changePosition ? "14.71vh" : "20.84vw",
top: styles.changePosition ? '2.95vh' : "3.91vw",
left: styles.changePosition ? '5.15vh' : "15.37vw",
},
circleTwo: {
width: styles.changePosition ? "2.21vh" : "2.22vw",
height: styles.changePosition ? "2.21vh" : "2.22vw",
top: styles.changePosition ? 'auto' : "18.23vw",
left: styles.changePosition ? '11.48vh' : "6.52vw",
bottom: styles.changePosition ? '-4.77vh' : "",
},
circleThree: {
width: styles.changePosition ? "3.31vh" : "1.96vw",
height: styles.changePosition ? "3.31vh" : "1.96vw",
top: styles.changePosition ? 'auto' : "44.28vw",
left: styles.changePosition ? '22.06vh' : "10.94vw",
bottom: styles.changePosition ? '-8.08vh' : "",
},
circleFour: {
width: styles.changePosition ? "14.71vh" : "1.31vw",
height: styles.changePosition ? "14.71vh" : "1.31vw",
top: styles.changePosition ? '0vh' : "12.37vw",
left: styles.changePosition ? '11.77vh' : "",
right: styles.changePosition ? 'auto' : "21.36vw",
},
circleSix: {
width: styles.changePosition ? "2.43vh" : "3.91vw",
height: styles.changePosition ? "2.43vh" : "3.91vw",
top: styles.changePosition ? '-2.2vh' : "31.52vw",
left: styles.changePosition ? '25.3vh' : "",
right: styles.changePosition ? 'auto' : "1.31vw",
},
circleSeven: {
width: styles.changePosition ? "14.71vh" : "1.96vw",
height: styles.changePosition ? "14.71vh" : "1.96vw",
top: styles.changePosition ? 'auto' : "40.11vw",
bottom: styles.changePosition ? '4.42vh' : "",
right: styles.changePosition ? '3.31vh' : "5.21vw",
},
scrollItem: {
opacity: styles.changePosition ? 0 : 1,
}
};
return (
<div className="Mainpage" id="mainpage">
<div style={mainPageStyle.bigCircle} className="Mainpage_bigCircle"></div>
<div style={mainPageStyle.smallCircle} className="Mainpage_smallCircle">
<div className="Mainpage_smallCircle_topArea">
<div style={mainPageStyle.title} className="Mainpage_smallCircle_topArea_title">
<div className="Mainpage_smallCircle_topArea_firttitle">
<img style={mainPageStyle.firstTitle} src={FirstTitle} />
</div>
<div className="Mainpage_smallCircle_topArea_secondtitle">
<img style={mainPageStyle.secondTitle} src={SecondTitle} />
</div>
</div>
<div style={mainPageStyle.whale} className="Mainpage_smallCircle_topArea_whale"></div>
<div style={mainPageStyle.bigWave} className="Mainpage_smallCircle_topArea_bigwave"></div>
<div style={mainPageStyle.smallWave} className="Mainpage_smallCircle_topArea_smallwave"></div>
<div style={mainPageStyle.loop} className="Mainpage_smallCircle_loop"></div>
<div style={mainPageStyle.titleSerif} className="Mainpage_smallCircle_topArea_titleSerif">
<img src={TitleSerif} />
</div>
<div style={mainPageStyle.titleSub} className="Mainpage_smallCircle_topArea_titleSub">
<img src={TitleSub} />
</div>
</div>
<div className="Mainpage_smallCircle_bottomArea">
<p style={mainPageStyle.bottomArea}>木の屋石巻水産では創業以来、
<br />さまざまな鯨の商品をお取り扱いしています。
<br />鯨料理は日本の伝統文化。
<br />鯨のことを知れば、
<br />もっと美味しくなります！
</p>
<div style={mainPageStyle.scrollItem} className="Mainpage_smallCircle_bottomArea_scroll">
<span></span>
</div>
</div>
</div>
<div style={mainPageStyle.circleArea} className="Mainpage_circleArea">
<div style={mainPageStyle.circleOne} className="Mainpage_circleArea_circleOne Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.circleTwo} className="Mainpage_circleArea_circleTwo Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.circleThree} className="Mainpage_circleArea_circleThree Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.circleFour} className="Mainpage_circleArea_circleFour Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.disapear} className="Mainpage_circleArea_circleFive Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.circleSix} className="Mainpage_circleArea_circleSix Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.circleSeven} className="Mainpage_circleArea_circleSeven Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.disapear} className="Mainpage_circleArea_circleEight Mainpage_circleArea_circleItem"></div>
<div style={mainPageStyle.disapear} className="Mainpage_circleArea_circleNine Mainpage_circleArea_circleItem"></div>
</div>
<div style={mainPageStyle.imageArea} className="Mainpage_imageArea">
<div style={mainPageStyle.foodOne} className="Mainpage_imageArea_foodOne">
<img src={foodOne} />
</div>
<div style={mainPageStyle.foodTwo} className="Mainpage_imageArea_foodTwo">
<img src={foodTwo} />
</div>
<div style={mainPageStyle.disapear} className="Mainpage_imageArea_foodThree">
<img src={foodThree} />
</div>
<div style={mainPageStyle.disapear} className="Mainpage_imageArea_foodFour">
<img src={foodFour} />
</div>
</div>
</div>
);
}
}
export default Mainpage;
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package com.discipular.service.impl;
import javax.ejb.Stateless;
import com.discipular.entity.Funcao;
import com.discipular.service.FuncaoService;
@Stateless
public class FuncaoServiceImpl extends CRUDServiceImpl<Funcao> implements FuncaoService {
private static final long serialVersionUID = 1L;
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 1 | package com.discipular.service.impl;
import javax.ejb.Stateless;
import com.discipular.entity.Funcao;
import com.discipular.service.FuncaoService;
@Stateless
public class FuncaoServiceImpl extends CRUDServiceImpl<Funcao> implements FuncaoService {
private static final long serialVersionUID = 1L;
} |
Below is an extract from a Swift program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Swift code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Swift concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., protocols, extensions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Swift. It should be similar to a school exercise, a tutorial, or a Swift course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Swift. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// SignUpViewController.swift
// GoogleFirebaseV1
//
// Created by <NAME> on 23.07.2018.
// Copyright © 2018 <NAME>. All rights reserved.
//
import UIKit
import Firebase
import FirebaseAuth
import FirebaseFirestore
import FirebaseStorage
class SignUpViewController: UIViewController, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
@IBOutlet weak var usernameTextField: UITextField!
@IBOutlet weak var emailTextField: UITextField!
@IBOutlet weak var passwordTextField: UITextField!
@IBOutlet weak var profilePic: UIImageView!
var ref: CollectionReference? = nil
var activityIndicator: UIActivityIndicatorView = UIActivityIndicatorView()
override func viewDidLoad() {
super.viewDidLoad()
ref = Firestore.firestore().collection("userCollection")
// Do any additional setup after loading the view.
}
@IBAction func SignUp(_ sender: UIButton) {
activityIndicator.center = self.view.center
activityIndicator.activityIndicatorViewStyle = .gray
view.addSubview(activityIndicator)
activityIndicator.startAnimating()
guard let username = usernameTextField.text, !username.isEmpty else { return }
guard let email = emailTextField.text, !email.isEmpty else { return }
guard let password = passwordTextField.text, !password.isEmpty else { return }
// let userData: [String: Any] = ["username": username , "email": email, "password": <PASSWORD>]
Auth.auth().createUser(withEmail: email, password: <PASSWORD>) { (user, err) in
if user != nil {
print("User Signed Up")
}
else {
print(":(")
}
let storageRef = Storage.storage().reference().child("profilePic/\(email)")
let uploadMetaData = StorageMetadata()
uploadMetaData.contentType =
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| swift | 2 | //
// SignUpViewController.swift
// GoogleFirebaseV1
//
// Created by <NAME> on 23.07.2018.
// Copyright © 2018 <NAME>. All rights reserved.
//
import UIKit
import Firebase
import FirebaseAuth
import FirebaseFirestore
import FirebaseStorage
class SignUpViewController: UIViewController, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
@IBOutlet weak var usernameTextField: UITextField!
@IBOutlet weak var emailTextField: UITextField!
@IBOutlet weak var passwordTextField: UITextField!
@IBOutlet weak var profilePic: UIImageView!
var ref: CollectionReference? = nil
var activityIndicator: UIActivityIndicatorView = UIActivityIndicatorView()
override func viewDidLoad() {
super.viewDidLoad()
ref = Firestore.firestore().collection("userCollection")
// Do any additional setup after loading the view.
}
@IBAction func SignUp(_ sender: UIButton) {
activityIndicator.center = self.view.center
activityIndicator.activityIndicatorViewStyle = .gray
view.addSubview(activityIndicator)
activityIndicator.startAnimating()
guard let username = usernameTextField.text, !username.isEmpty else { return }
guard let email = emailTextField.text, !email.isEmpty else { return }
guard let password = passwordTextField.text, !password.isEmpty else { return }
// let userData: [String: Any] = ["username": username , "email": email, "password": <PASSWORD>]
Auth.auth().createUser(withEmail: email, password: <PASSWORD>) { (user, err) in
if user != nil {
print("User Signed Up")
}
else {
print(":(")
}
let storageRef = Storage.storage().reference().child("profilePic/\(email)")
let uploadMetaData = StorageMetadata()
uploadMetaData.contentType = "image/jpeg"
let uploadImage = UIImageJPEGRepresentation(self.profilePic.image!, 0.8)
storageRef.putData(uploadImage!, metadata: uploadMetaData) { (metadata, error) in
if error != nil {
print("Error! \(String(describing: error?.localizedDescription))")
}
else{
print("Upload Complete! \(String(describing: metadata))")
}
storageRef.downloadURL(completion: { (url, error) in
guard let downloadURL = url else { return }
let urlString = downloadURL.absoluteString
print("image url: \(urlString)")
let userData: [String: Any] = ["username": username , "email": email, "<PASSWORD>": <PASSWORD>,"profilePic": urlString ]
self.signUpUserIntoDatabse(dataToSaveDatabase: userData)
})
}
}
}
func signUpUserIntoDatabse(dataToSaveDatabase: [String: Any]){
self.ref?.addDocument(data: dataToSaveDatabase) { err in
if let err = err {
print("Oh no! Got an error: \(err.localizedDescription)")
}
else {
print("Data has been saved!")
self.activityIndicator.stopAnimating()
}
}
}
@IBAction func SelectFromLibrary(_ sender: UIButton) {
let profileImg = UIImagePickerController()
profileImg.delegate = self
profileImg.sourceType = .photoLibrary
profileImg.allowsEditing = false
self.present(profileImg, animated: true){}
}
func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
if let image = info[UIImagePickerControllerOriginalImage] as? UIImage{
profilePic.image = image
}
self.dismiss(animated: true, completion: nil)
}
// MARK: End of UIViewController Class
}
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
ALTER IGNORE TABLE `character_blocklist` DROP `target_Name`;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | ALTER IGNORE TABLE `character_blocklist` DROP `target_Name`; |
Below is an extract from a shell script. Evaluate whether it has a high educational value and could help teach shell scripting. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the script contains valid shell commands, even if it's not educational, like simple system calls or basic file operations.
- Add another point if the script addresses practical shell scripting concepts (e.g., variables, conditionals), even if it lacks comments.
- Award a third point if the script is suitable for educational use and introduces key concepts in shell scripting, even if the topic is somewhat advanced (e.g., functions, process management). The script should be well-structured and contain some comments.
- Give a fourth point if the script is self-contained and highly relevant to teaching shell scripting. It should be similar to a tutorial example or a shell scripting course section, demonstrating good practices in script organization.
- Grant a fifth point if the script is outstanding in its educational value and is perfectly suited for teaching shell scripting. It should be well-written, easy to understand, and contain step-by-step explanations in comments.
The extract:
#!/bin/sh
# if the branch is main, then fail.
branch="$(git symbolic-ref HEAD 2>/dev/null)" || \
"$(git describe --contains --all HEAD)"
if [ "${branch##refs/heads/}" = "main" ]; then
printf "\e[31m%s\n\e[m" "[Error]"
echo "can't commit on main branch."
echo "please commit on topic branch."
exit 1
fi
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| shell | 3 | #!/bin/sh
# if the branch is main, then fail.
branch="$(git symbolic-ref HEAD 2>/dev/null)" || \
"$(git describe --contains --all HEAD)"
if [ "${branch##refs/heads/}" = "main" ]; then
printf "\e[31m%s\n\e[m" "[Error]"
echo "can't commit on main branch."
echo "please commit on topic branch."
exit 1
fi
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#![allow(unreachable_code)]
fn main() {
let mut count = 0u32;
println!("Lets count until infinity!");
loop {
count += 1;
if count == 3 {
println!("three");
continue;
}
println!("{}",count);
if count == 5 {
println!("OK, that's enough");
break;
}
}
//labelling loop
'outer: loop {
println!("Entered the outer loop");
'inner: loop {
println!("Entered the inner loop");
break 'outer;
}
println!("this point will never be reached");
}
println!("Exited the outer loop");
//return from loop
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2
}
};
assert_eq!(result, 20);
println!("Result is {}", result);
//while loop example
let mut n = 0u32;
while n < 101 {
if n % 15 == 0 {
println!("Fizzbuzz");
}else if n % 3 == 0 {
println!("Fizz");
}else if n % 5 == 0 {
println!("Buzz");
}else {
println!("{}",n);
}
n += 1;
}
// for and range example
for n in 1..=100 {
if n % 15 == 0 {
println!("FIZZBUZZ");
}else if n % 3 == 0 {
println!("FIZZ");
}else if n % 5 == 0 {
println!("BUZZ");
}else {
println!("{}",n);
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 5 | #![allow(unreachable_code)]
fn main() {
let mut count = 0u32;
println!("Lets count until infinity!");
loop {
count += 1;
if count == 3 {
println!("three");
continue;
}
println!("{}",count);
if count == 5 {
println!("OK, that's enough");
break;
}
}
//labelling loop
'outer: loop {
println!("Entered the outer loop");
'inner: loop {
println!("Entered the inner loop");
break 'outer;
}
println!("this point will never be reached");
}
println!("Exited the outer loop");
//return from loop
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2
}
};
assert_eq!(result, 20);
println!("Result is {}", result);
//while loop example
let mut n = 0u32;
while n < 101 {
if n % 15 == 0 {
println!("Fizzbuzz");
}else if n % 3 == 0 {
println!("Fizz");
}else if n % 5 == 0 {
println!("Buzz");
}else {
println!("{}",n);
}
n += 1;
}
// for and range example
for n in 1..=100 {
if n % 15 == 0 {
println!("FIZZBUZZ");
}else if n % 3 == 0 {
println!("FIZZ");
}else if n % 5 == 0 {
println!("BUZZ");
}else {
println!("{}",n);
}
}
} |
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
/* These code was generated using phpCIGen v 0.1.b (21/04/2009)
#zaqi <EMAIL>,http://zenzaqi.blogspot.com,
+ Module : draft Controller
+ Description : For record controller process back-end
+ Filename : C_draft.php
+ creator :
+ Created on 01/Feb/2010 14:30:05
*/
//class of draft
class C_draft extends Controller {
//constructor
function C_draft(){
parent::Controller();
session_start();
$this->load->model('m_draft', '', TRUE);
$this->load->model('m_phonegroup', '', TRUE);
}
//set index
function index(){
$this->load->helper('asset');
$this->load->view('main/v_draft');
}
function get_customer_list(){
$query = isset($_POST['query']) ? $_POST['query'] : "";
$start = (integer) (isset($_POST['start']) ? $_POST['start'] : $_GET['start']);
$end = (integer) (isset($_POST['limit']) ? $_POST['limit'] : $_GET['limit']);
$result=$this->m_public_function->get_customer_list($query,$start,$end);
echo $result;
}
//event handler action
function get_action(){
$task = $_POST['task'];
switch($task){
case "LIST":
$this->draft_list();
break;
case "UPDATE":
$this->draft_update();
break;
case "CREATE":
$this->draft_create();
break;
case "DELETE":
$this->draft_delete();
break;
case "SEARCH":
$this->draft_search();
break;
case "PRINT":
$this->draft_print();
break;
case "EXCEL":
$this->draft_export_excel();
break;
default:
echo "{failure:true}";
break;
}
}
function draft_save(){
$idraft_id = (isset($_POST['idraft_id']) ? @$_POST['idraft_id'] : @$_GET['idraft_id']);
$idraft_dest = (isset($_POST['idraft_dest']) ? @$_POST['idraft_dest'] : @$_GET['idraft_dest']);
$idraft_isi = (isset($_POST['idraft_isi']) ? @$_POST['idraft_isi'] : @$_GET['idraft_isi']);
$idraft_opsi = (isset($_POST['idraft_opsi']) ? @$_POST['idraft_opsi'] : @$_GET['idraft_opsi']);
$id
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 3 | <?php
/* These code was generated using phpCIGen v 0.1.b (21/04/2009)
#zaqi <EMAIL>,http://zenzaqi.blogspot.com,
+ Module : draft Controller
+ Description : For record controller process back-end
+ Filename : C_draft.php
+ creator :
+ Created on 01/Feb/2010 14:30:05
*/
//class of draft
class C_draft extends Controller {
//constructor
function C_draft(){
parent::Controller();
session_start();
$this->load->model('m_draft', '', TRUE);
$this->load->model('m_phonegroup', '', TRUE);
}
//set index
function index(){
$this->load->helper('asset');
$this->load->view('main/v_draft');
}
function get_customer_list(){
$query = isset($_POST['query']) ? $_POST['query'] : "";
$start = (integer) (isset($_POST['start']) ? $_POST['start'] : $_GET['start']);
$end = (integer) (isset($_POST['limit']) ? $_POST['limit'] : $_GET['limit']);
$result=$this->m_public_function->get_customer_list($query,$start,$end);
echo $result;
}
//event handler action
function get_action(){
$task = $_POST['task'];
switch($task){
case "LIST":
$this->draft_list();
break;
case "UPDATE":
$this->draft_update();
break;
case "CREATE":
$this->draft_create();
break;
case "DELETE":
$this->draft_delete();
break;
case "SEARCH":
$this->draft_search();
break;
case "PRINT":
$this->draft_print();
break;
case "EXCEL":
$this->draft_export_excel();
break;
default:
echo "{failure:true}";
break;
}
}
function draft_save(){
$idraft_id = (isset($_POST['idraft_id']) ? @$_POST['idraft_id'] : @$_GET['idraft_id']);
$idraft_dest = (isset($_POST['idraft_dest']) ? @$_POST['idraft_dest'] : @$_GET['idraft_dest']);
$idraft_isi = (isset($_POST['idraft_isi']) ? @$_POST['idraft_isi'] : @$_GET['idraft_isi']);
$idraft_opsi = (isset($_POST['idraft_opsi']) ? @$_POST['idraft_opsi'] : @$_GET['idraft_opsi']);
$idraft_task = (isset($_POST['idraft_task']) ? @$_POST['idraft_task'] : @$_GET['idraft_task']);
$idraft_jnsklm = (isset($_POST['idraft_jnsklm']) ? @$_POST['idraft_jnsklm'] : @$_GET['idraft_jnsklm']);
$idraft_ultah = (isset($_POST['idraft_ultah']) ? @$_POST['idraft_ultah'] : @$_GET['idraft_ultah']);
$idraft_crm = (isset($_POST['idraft_crm']) ? @$_POST['idraft_crm'] : @$_GET['idraft_crm']);
if($idraft_task=="send"){
$result=$this->m_phonegroup->sms_save($idraft_dest,$idraft_isi,$idraft_opsi,$idraft_task, $idraft_jnsklm, $idraft_ultah, $idraft_crm);
// $result=$this->m_draft->draft_delete($idraft_id);
}else{
$draft_date=date('Y/m/d H:i:s');
$draft_update=$_SESSION[SESSION_USERID];
$draft_date_update=date("Y/m/d H:i:s");
$result = $this->m_draft->draft_update($idraft_id,$idraft_dest,$idraft_isi,$idraft_opsi,$idraft_task,$draft_update,$draft_date_update);
}
echo $result;
}
//function fot list record
function draft_list(){
$query = isset($_POST['query']) ? @$_POST['query'] : "";
$start = (integer) (isset($_POST['start']) ? @$_POST['start'] : @$_GET['start']);
$end = (integer) (isset($_POST['limit']) ? @$_POST['limit'] : @$_GET['limit']);
$result=$this->m_draft->draft_list($query,$start,$end);
echo $result;
}
//function for create new record
function draft_create(){
//POST varible here
//auto increment, don't accept anything from form values
$draft_destination=trim(@$_POST["draft_destination"]);
$draft_destination=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_destination);
$draft_destination=str_replace("'", "''",$draft_destination);
$draft_message=trim(@$_POST["draft_message"]);
$draft_message=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_message);
$draft_message=str_replace("'", "''",$draft_message);
$draft_date=trim(@$_POST["draft_date"]);
$draft_creator=@$_SESSION[SESSION_USERID];
$draft_date_create=date('m/d/Y');
//$draft_update=NULL;
//$draft_date_update=NULL;
//$draft_revised=0;
$result=$this->m_draft->draft_create($draft_destination ,$draft_message ,$draft_date ,$draft_creator ,$draft_date_create );
echo $result;
}
//function for update record
function draft_update(){
//POST variable here
$draft_id=trim(@$_POST["draft_id"]);
$draft_destination=trim(@$_POST["draft_destination"]);
$draft_destination=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_destination);
$draft_destination=str_replace("'", "''",$draft_destination);
$draft_message=trim(@$_POST["draft_message"]);
$draft_message=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_message);
$draft_message=str_replace("'", "''",$draft_message);
$draft_date=trim(@$_POST["draft_date"]);
//$draft_creator="draft_creator";
//$draft_date_create="draft_date_create";
$draft_update=@$_SESSION[SESSION_USERID];
$draft_date_update=date('m/d/Y');
//$draft_revised="(revised+1)";
$result = $this->m_draft->draft_update($draft_id,$draft_destination,$draft_message,$draft_date,$draft_update,$draft_date_update);
echo $result;
}
//function for delete selected record
function draft_delete(){
$ids = @$_POST['ids']; // Get our array back and translate it :
$pkid = json_decode(stripslashes($ids));
$result=$this->m_draft->draft_delete($pkid);
echo $result;
}
//function for advanced search
function draft_search(){
//POST varibale here
$draft_id=trim(@$_POST["draft_id"]);
$draft_destnama=trim(@$_POST["draft_destnama"]);
$draft_destnama=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_destnama);
$draft_destnama=str_replace("'", "''",$draft_destnama);
$draft_jenis=trim(@$_POST["draft_jenis"]);
$draft_jenis=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_jenis);
$draft_jenis=str_replace("'", "''",$draft_jenis);
$draft_message=trim(@$_POST["draft_message"]);
$draft_message=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_message);
$draft_message=str_replace("'", "''",$draft_message);
$draft_date=trim(@$_POST["draft_date"]);
$draft_creator=trim(@$_POST["draft_creator"]);
$draft_creator=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_creator);
$draft_creator=str_replace("'", "''",$draft_creator);
$draft_date_create=trim(@$_POST["draft_date_create"]);
$draft_update=trim(@$_POST["draft_update"]);
$draft_update=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_update);
$draft_update=str_replace("'", "''",$draft_update);
$draft_date_update=trim(@$_POST["draft_date_update"]);
$draft_revised=trim(@$_POST["draft_revised"]);
$start = (integer) (isset($_POST['start']) ? $_POST['start'] : $_GET['start']);
$end = (integer) (isset($_POST['limit']) ? $_POST['limit'] : $_GET['limit']);
$result = $this->m_draft->draft_search($draft_id ,$draft_destnama, $draft_jenis,$draft_message ,$draft_date ,$draft_creator ,
$draft_date_create ,$draft_update ,$draft_date_update ,$draft_revised ,$start,$end);
echo $result;
}
function draft_print(){
//POST varibale here
$draft_id=trim(@$_POST["draft_id"]);
$draft_destnama=trim(@$_POST["draft_destnama"]);
$draft_destnama=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_destnama);
$draft_destnama=str_replace("'", "''",$draft_destnama);
$draft_jenis=trim(@$_POST["draft_jenis"]);
$draft_jenis=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_jenis);
$draft_jenis=str_replace("'", "''",$draft_jenis);
$draft_message=trim(@$_POST["draft_message"]);
$draft_message=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_message);
$draft_message=str_replace("'", "'",$draft_message);
$draft_date=trim(@$_POST["draft_date"]);
$draft_creator=trim(@$_POST["draft_creator"]);
$draft_creator=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_creator);
$draft_creator=str_replace("'", "'",$draft_creator);
$draft_date_create=trim(@$_POST["draft_date_create"]);
$draft_update=trim(@$_POST["draft_update"]);
$draft_update=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_update);
$draft_update=str_replace("'", "'",$draft_update);
$draft_date_update=trim(@$_POST["draft_date_update"]);
$draft_revised=trim(@$_POST["draft_revised"]);
$option=$_POST['currentlisting'];
$filter=$_POST["query"];
$data["data_print"] = $this->m_draft->draft_print($draft_id ,$draft_destnama, $draft_jenis ,$draft_message ,$draft_date ,$draft_creator ,
$draft_date_create ,$draft_update ,$draft_date_update ,$draft_revised ,$option,$filter);
$print_view=$this->load->view("main/p_draft.php",$data,TRUE);
if(!file_exists("print")){
mkdir("print");
}
$print_file=fopen("print/draft_printlist.html","w+");
fwrite($print_file, $print_view);
echo '1';
}
/* End Of Function */
/* Function to Export Excel document */
function draft_export_excel(){
//POST varibale here
$draft_id=trim(@$_POST["draft_id"]);
$draft_destnama=trim(@$_POST["draft_destnama"]);
$draft_destnama=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_destnama);
$draft_destnama=str_replace("'", "''",$draft_destnama);
$draft_jenis=trim(@$_POST["draft_jenis"]);
$draft_jenis=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_jenis);
$draft_jenis=str_replace("'", "''",$draft_jenis);
$draft_message=trim(@$_POST["draft_message"]);
$draft_message=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_message);
$draft_message=str_replace("'", "''",$draft_message);
$draft_date=trim(@$_POST["draft_date"]);
$draft_creator=trim(@$_POST["draft_creator"]);
$draft_creator=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_creator);
$draft_creator=str_replace("'", "''",$draft_creator);
$draft_date_create=trim(@$_POST["draft_date_create"]);
$draft_update=trim(@$_POST["draft_update"]);
$draft_update=str_replace("/(<\/?)(p)([^>]*>)", "",$draft_update);
$draft_update=str_replace("'", "''",$draft_update);
$draft_date_update=trim(@$_POST["draft_date_update"]);
$draft_revised=trim(@$_POST["draft_revised"]);
$option=$_POST['currentlisting'];
$filter=$_POST["query"];
$query = $this->m_draft->draft_export_excel($draft_id ,$draft_destnama, $draft_jenis ,$draft_message ,$draft_date ,$draft_creator ,
$draft_date_create ,$draft_update ,$draft_date_update ,$draft_revised ,$option,$filter);
$this->load->plugin('to_excel');
to_excel($query,"draft");
echo '1';
}
// Encodes a SQL array into a JSON formated string
function JEncode($arr){
if (version_compare(PHP_VERSION,"5.2","<"))
{
require_once("./JSON.php"); //if php<5.2 need JSON class
$json = new Services_JSON();//instantiate new json object
$data=$json->encode($arr); //encode the data in json format
} else {
$data = json_encode($arr); //encode the data in json format
}
return $data;
}
// Decode a SQL array into a JSON formated string
function JDecode($arr){
if (version_compare(PHP_VERSION,"5.2","<"))
{
require_once("./JSON.php"); //if php<5.2 need JSON class
$json = new Services_JSON();//instantiate new json object
$data=$json->decode($arr); //decode the data in json format
} else {
$data = json_decode($arr); //decode the data in json format
}
return $data;
}
// Encodes a YYYY-MM-DD into a MM-DD-YYYY string
function codeDate ($date) {
$tab = explode ("-", $date);
$r = $tab[1]."/".$tab[2]."/".$tab[0];
return $r;
}
}
?> |
Below is an extract from a Kotlin program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Kotlin code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Kotlin concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., coroutines, extension functions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Kotlin. It should be similar to a school exercise, a tutorial, or a Kotlin course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Kotlin. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package fr.slickteam.gitlabciittests.entity
import java.time.Instant
@Suppress("ConstructorParameterNaming")
data class Movie(
val _id: String? = null,
val title: String,
val director: String? = null,
val releaseDate: Instant? = null) {
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as Movie
if (_id != other._id) return false
if (title != other.title) return false
if (director != other.director) return false
return true
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| kotlin | 3 | package fr.slickteam.gitlabciittests.entity
import java.time.Instant
@Suppress("ConstructorParameterNaming")
data class Movie(
val _id: String? = null,
val title: String,
val director: String? = null,
val releaseDate: Instant? = null) {
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as Movie
if (_id != other._id) return false
if (title != other.title) return false
if (director != other.director) return false
return true
}
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
var socket;
// socket = io.connect('192.168.43.125:3000');
// socket = io.connect('192.168.100.5:3000');
// socket = io.connect('localhost:5000');
socket = io.connect();
// VAR miscellaneous
var mail_trigger = document.getElementsByClassName('send')[0]; // send email via form
var message = document.getElementsByClassName('done')[0]; // non mi ricordo a cosa serva
var vid_start = document.getElementsByClassName('finish')[0]; // start video in loop sulla pistola
var vid_end = document.getElementsByClassName('components_wrapper')[0]; // end video in loop sulla pistola
// VAR for sockets
var v_co_1 = document.getElementsByClassName('magenta')[0],
v_ca_1 = document.getElementsByClassName('magenta')[1],
v_gr_1 = document.getElementsByClassName('magenta')[2],
v_de_1 = document.getElementsByClassName('magenta')[3];
var v_co_2 = document.getElementsByClassName('calx')[0],
v_ca_2 = document.getElementsByClassName('calx')[1],
v_gr_2 = document.getElementsByClassName('calx')[2],
v_de_2 = document.getElementsByClassName('calx')[3];
var v_co_3 = document.getElementsByClassName('lime')[0],
v_ca_3 = document.getElementsByClassName('lime')[1],
v_gr_3 = document.getElementsByClassName('lime')[2],
v_de_3 = document.getElementsByClassName('lime')[3];
var v_co_4 = document.getElementsByClassName('extramarine')[0],
v_ca_4 = document.getElementsByClassName('extramarine')[1],
v_gr_4 = document.getElementsByClassName('extramarine')[2],
v_de_4 = document.getElementsByClassName('extramarine')[3];
var v_co_5 = document.getElementsByClassName('obsidian')[0],
v_ca_5 = document.getElementsByClassName('obsidian')[1],
v_gr_5 = document.getElementsByClassName('obsidian')[2],
v_de_5 = document.getElementsByClassName('obsidian')[3];
var v_co_6 = document.getElementsByClassName('white')[0],
v_ca_6 = document.getElementsByClassName('white')[1],
v_gr_6 = document.getElementsByClassName('white')[2],
v_de_6 = document.getElemen
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 1 | var socket;
// socket = io.connect('192.168.43.125:3000');
// socket = io.connect('192.168.100.5:3000');
// socket = io.connect('localhost:5000');
socket = io.connect();
// VAR miscellaneous
var mail_trigger = document.getElementsByClassName('send')[0]; // send email via form
var message = document.getElementsByClassName('done')[0]; // non mi ricordo a cosa serva
var vid_start = document.getElementsByClassName('finish')[0]; // start video in loop sulla pistola
var vid_end = document.getElementsByClassName('components_wrapper')[0]; // end video in loop sulla pistola
// VAR for sockets
var v_co_1 = document.getElementsByClassName('magenta')[0],
v_ca_1 = document.getElementsByClassName('magenta')[1],
v_gr_1 = document.getElementsByClassName('magenta')[2],
v_de_1 = document.getElementsByClassName('magenta')[3];
var v_co_2 = document.getElementsByClassName('calx')[0],
v_ca_2 = document.getElementsByClassName('calx')[1],
v_gr_2 = document.getElementsByClassName('calx')[2],
v_de_2 = document.getElementsByClassName('calx')[3];
var v_co_3 = document.getElementsByClassName('lime')[0],
v_ca_3 = document.getElementsByClassName('lime')[1],
v_gr_3 = document.getElementsByClassName('lime')[2],
v_de_3 = document.getElementsByClassName('lime')[3];
var v_co_4 = document.getElementsByClassName('extramarine')[0],
v_ca_4 = document.getElementsByClassName('extramarine')[1],
v_gr_4 = document.getElementsByClassName('extramarine')[2],
v_de_4 = document.getElementsByClassName('extramarine')[3];
var v_co_5 = document.getElementsByClassName('obsidian')[0],
v_ca_5 = document.getElementsByClassName('obsidian')[1],
v_gr_5 = document.getElementsByClassName('obsidian')[2],
v_de_5 = document.getElementsByClassName('obsidian')[3];
var v_co_6 = document.getElementsByClassName('white')[0],
v_ca_6 = document.getElementsByClassName('white')[1],
v_gr_6 = document.getElementsByClassName('white')[2],
v_de_6 = document.getElementsByClassName('white')[3];
var v_co_7 = document.getElementsByClassName('orange')[0],
v_ca_7 = document.getElementsByClassName('orange')[1],
v_gr_7 = document.getElementsByClassName('orange')[2],
v_de_7 = document.getElementsByClassName('orange')[3];
var v_co_8 = document.getElementsByClassName('fuck')[0],
v_ca_8 = document.getElementsByClassName('fuck')[1],
v_gr_8 = document.getElementsByClassName('fuck')[2],
v_de_8 = document.getElementsByClassName('fuck')[3];
// Texture VAR
var v_tco_1 = document.getElementsByClassName('t_1')[0],
v_tca_1 = document.getElementsByClassName('t_1')[1];
var v_tco_2 = document.getElementsByClassName('t_2')[0],
v_tca_2 = document.getElementsByClassName('t_2')[1];
var v_tco_3 = document.getElementsByClassName('t_3')[0],
v_tca_3 = document.getElementsByClassName('t_3')[1];
var v_tco_4 = document.getElementsByClassName('t_4')[0],
v_tca_4 = document.getElementsByClassName('t_4')[1];
var v_tco_5 = document.getElementsByClassName('t_5')[0],
v_tca_5 = document.getElementsByClassName('t_5')[1];
var v_tco_6 = document.getElementsByClassName('t_6')[0],
v_tca_6 = document.getElementsByClassName('t_6')[1];
var v_tco_7 = document.getElementsByClassName('t_7')[0],
v_tca_7 = document.getElementsByClassName('t_7')[1];
var v_tco_8 = document.getElementsByClassName('t_8')[0],
v_tca_8 = document.getElementsByClassName('t_8')[1];
// send email via form
mail_trigger.addEventListener('click', function(){
socket.emit('mail_sender', {});
});
// Start & stop video on gun
vid_start.addEventListener('click', function(){
socket.emit('video_start', {
});
console.log('video start');
})
vid_end.addEventListener('click', function(){
socket.emit('video_end', {
});
console.log('video end');
});
// Socket for calcio
v_co_1.addEventListener('click', function(){
socket.emit('co_1', {
});
});
v_co_2.addEventListener('click', function(){
socket.emit('co_2', {
});
});
v_co_3.addEventListener('click', function(){
socket.emit('co_3', {
});
});
v_co_4.addEventListener('click', function(){
socket.emit('co_4', {
});
});
v_co_5.addEventListener('click', function(){
socket.emit('co_5', {
});
});
v_co_6.addEventListener('click', function(){
socket.emit('co_6', {
});
});
v_co_7.addEventListener('click', function(){
socket.emit('co_7', {
});
});
v_co_8.addEventListener('click', function(){
socket.emit('co_8', {
});
});
v_tco_1.addEventListener('click', function(){
socket.emit('tco_1', {
});
});
v_tco_2.addEventListener('click', function(){
socket.emit('tco_2', {
});
});
v_tco_3.addEventListener('click', function(){
socket.emit('tco_3', {
});
});
v_tco_4.addEventListener('click', function(){
socket.emit('tco_4', {
});
});
v_tco_5.addEventListener('click', function(){
socket.emit('tco_5', {
});
});
v_tco_6.addEventListener('click', function(){
socket.emit('tco_6', {
});
});
v_tco_7.addEventListener('click', function(){
socket.emit('tco_7', {
});
});
v_tco_8.addEventListener('click', function(){
socket.emit('tco_8', {
});
});
// Socket for canna
v_ca_1.addEventListener('click', function(){
socket.emit('ca_1', {
});
});
v_ca_2.addEventListener('click', function(){
socket.emit('ca_2', {
});
});
v_ca_3.addEventListener('click', function(){
socket.emit('ca_3', {
});
});
v_ca_4.addEventListener('click', function(){
socket.emit('ca_4', {
});
});
v_ca_5.addEventListener('click', function(){
socket.emit('ca_5', {
});
});
v_ca_6.addEventListener('click', function(){
socket.emit('ca_6', {
});
});
v_ca_7.addEventListener('click', function(){
socket.emit('ca_7', {
});
});
v_ca_8.addEventListener('click', function(){
socket.emit('ca_8', {
});
});
v_tca_1.addEventListener('click', function(){
socket.emit('tca_1', {
});
});
v_tca_2.addEventListener('click', function(){
socket.emit('tca_2', {
});
});
v_tca_3.addEventListener('click', function(){
socket.emit('tca_3', {
});
});
v_tca_4.addEventListener('click', function(){
socket.emit('tca_4', {
});
});
v_tca_5.addEventListener('click', function(){
socket.emit('tca_5', {
});
});
v_tca_6.addEventListener('click', function(){
socket.emit('tca_6', {
});
});
v_tca_7.addEventListener('click', function(){
socket.emit('tca_7', {
});
});
v_tca_8.addEventListener('click', function(){
socket.emit('tca_8', {
});
});
// Socket for grilletto
v_gr_1.addEventListener('click', function(){
socket.emit('gr_1', {
});
});
v_gr_2.addEventListener('click', function(){
socket.emit('gr_2', {
});
});
v_gr_3.addEventListener('click', function(){
socket.emit('gr_3', {
});
});
v_gr_4.addEventListener('click', function(){
socket.emit('gr_4', {
});
});
v_gr_5.addEventListener('click', function(){
socket.emit('gr_5', {
});
});
v_gr_6.addEventListener('click', function(){
socket.emit('gr_6', {
});
});
v_gr_7.addEventListener('click', function(){
socket.emit('gr_7', {
});
});
v_gr_8.addEventListener('click', function(){
socket.emit('gr_8', {
});
});
// Socket for dettagli
v_de_1.addEventListener('click', function(){
socket.emit('de_1', {
});
});
v_de_2.addEventListener('click', function(){
socket.emit('de_2', {
});
});
v_de_3.addEventListener('click', function(){
socket.emit('de_3', {
});
});
v_de_4.addEventListener('click', function(){
socket.emit('de_4', {
});
});
v_de_5.addEventListener('click', function(){
socket.emit('de_5', {
});
});
v_de_6.addEventListener('click', function(){
socket.emit('de_6', {
});
});
v_de_7.addEventListener('click', function(){
socket.emit('de_7', {
});
});
v_de_8.addEventListener('click', function(){
socket.emit('de_8', {
});
});
// LISTENER FOR EVENTS
// Start & stop video on gun
socket.on('r_vid_start', start_video);
function start_video(data) {
$('.video_loop').show('fast');
$('#calcio, #canna, #grilletto, #dettagli').children('div').removeClass('projected'); // remove all the colors and show video
};
socket.on('r_vid_end', end_video);
function end_video(data){
$('.video_loop').hide("fast");
};
//Calcio 1
socket.on('r_co_1', co_1);
function co_1(data){
console.log('calcio 1');
$('.magenta_co').addClass('projected');
$('#calcio').children('div').not('.magenta_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 2
socket.on('r_co_2', co_2);
function co_2(data){
console.log('calcio 2');
$('.calx_co').addClass('projected');
$('#calcio').children('div').not('.calx_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 3
socket.on('r_co_3', co_3);
function co_3(data){
console.log('calcio 3');
$('.lime_co').addClass('projected');
$('#calcio').children('div').not('.lime_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 4
socket.on('r_co_4', co_4);
function co_4(data){
console.log('calcio 4');
$('.extramarine_co').addClass('projected');
$('#calcio').children('div').not('.extramarine_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 5
socket.on('r_co_5', co_5);
function co_5(data){
console.log('calcio 5');
$('.obsidian_co').addClass('projected');
$('#calcio').children('div').not('.obsidian_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 6
socket.on('r_co_6', co_6);
function co_6(data){
console.log('calcio 6');
$('.white_co').addClass('projected');
$('#calcio').children('div').not('.white_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 7
socket.on('r_co_7', co_7);
function co_7(data){
console.log('calcio 7');
$('.orange_co').addClass('projected');
$('#calcio').children('div').not('.orange_co').removeClass('projected'); // remove Class from other parts
};
//Calcio 8
socket.on('r_co_8', co_8);
function co_8(data){
console.log('calcio 8');
$('.fuck_co').addClass('projected');
$('#calcio').children('div').not('.fuck_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 1
socket.on('r_tco_1', tco_1);
function tco_1(data){
console.log('calcio T 1');
$('.t_1_co').addClass('projected');
$('#calcio').children('div').not('.t_1_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 2
socket.on('r_tco_2', tco_2);
function tco_2(data){
console.log('calcio T 2');
$('.t_2_co').addClass('projected');
$('#calcio').children('div').not('.t_2_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 3
socket.on('r_tco_3', tco_3);
function tco_3(data){
console.log('calcio T 3');
$('.t_3_co').addClass('projected');
$('#calcio').children('div').not('.t_3_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 4
socket.on('r_tco_4', tco_4);
function tco_4(data){
console.log('calcio T 4');
$('.t_4_co').addClass('projected');
$('#calcio').children('div').not('.t_4_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 5
socket.on('r_tco_5', tco_5);
function tco_5(data){
console.log('calcio T 5');
$('.t_5_co').addClass('projected');
$('#calcio').children('div').not('.t_5_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 6
socket.on('r_tco_6', tco_6);
function tco_6(data){
console.log('calcio T 6');
$('.t_6_co').addClass('projected');
$('#calcio').children('div').not('.t_6_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 7
socket.on('r_tco_7', tco_7);
function tco_7(data){
console.log('calcio T 7');
$('.t_7_co').addClass('projected');
$('#calcio').children('div').not('.t_7_co').removeClass('projected'); // remove Class from other parts
};
//Calcio T 8
socket.on('r_tco_8', tco_8);
function tco_8(data){
console.log('calcio T 8');
$('.t_8_co').addClass('projected');
$('#calcio').children('div').not('.t_8_co').removeClass('projected'); // remove Class from other parts
};
//Canna 1
socket.on('r_ca_1', ca_1);
function ca_1(data){
console.log('canna 1');
$('.magenta_ca').addClass('projected');
$('#canna').children('div').not('.magenta_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 2
socket.on('r_ca_2', ca_2);
function ca_2(data){
console.log('canna 2');
$('.calx_ca').addClass('projected');
$('#canna').children('div').not('.calx_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 3
socket.on('r_ca_3', ca_3);
function ca_3(data){
console.log('canna 3');
$('.lime_ca').addClass('projected');
$('#canna').children('div').not('.lime_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 4
socket.on('r_ca_4', ca_4);
function ca_4(data){
console.log('canna 4');
$('.extramarine_ca').addClass('projected');
$('#canna').children('div').not('.extramarine_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 5
socket.on('r_ca_5', ca_5);
function ca_5(data){
console.log('canna 5');
$('.obsidian_ca').addClass('projected');
$('#canna').children('div').not('.obsidian_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 6
socket.on('r_ca_6', ca_6);
function ca_6(data){
console.log('canna 6');
$('.white_ca').addClass('projected');
$('#canna').children('div').not('.white_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 7
socket.on('r_ca_7', ca_7);
function ca_7(data){
console.log('canna 7');
$('.orange_ca').addClass('projected');
$('#canna').children('div').not('.orange_ca').removeClass('projected'); // remove Class from other parts
};
//Canna 8
socket.on('r_ca_8', ca_8);
function ca_8(data){
console.log('canna 8');
$('.fuck_ca').addClass('projected');
$('#canna').children('div').not('.fuck_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 1
socket.on('r_tca_1', tca_1);
function tca_1(data){
console.log('canna T 1');
$('.t_1_ca').addClass('projected');
$('#canna').children('div').not('.t_1_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 2
socket.on('r_tca_2', tca_2);
function tca_2(data){
console.log('canna T 2');
$('.t_2_ca').addClass('projected');
$('#canna').children('div').not('.t_2_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 3
socket.on('r_tca_3', tca_3);
function tca_3(data){
console.log('canna T 3');
$('.t_3_ca').addClass('projected');
$('#canna').children('div').not('.t_3_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 4
socket.on('r_tca_4', tca_4);
function tca_4(data){
console.log('canna T 4');
$('.t_4_ca').addClass('projected');
$('#canna').children('div').not('.t_4_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 5
socket.on('r_tca_5', tca_5);
function tca_5(data){
console.log('canna T 5');
$('.t_5_ca').addClass('projected');
$('#canna').children('div').not('.t_5_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 6
socket.on('r_tca_6', tca_6);
function tca_6(data){
console.log('canna T 6');
$('.t_6_ca').addClass('projected');
$('#canna').children('div').not('.t_6_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 7
socket.on('r_tca_7', tca_7);
function tca_7(data){
console.log('canna T 7');
$('.t_7_ca').addClass('projected');
$('#canna').children('div').not('.t_7_ca').removeClass('projected'); // remove Class from other parts
};
//Canna T 8
socket.on('r_tca_8', tca_8);
function tca_8(data){
console.log('canna T 8');
$('.t_8_ca').addClass('projected');
$('#canna').children('div').not('.t_8_ca').removeClass('projected'); // remove Class from other parts
};
//grilletto 1
socket.on('r_gr_1', gr_1);
function gr_1(data){
console.log('grilletto 1');
$('.magenta_gr').addClass('projected');
$('#grilletto').children('div').not('.magenta_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 2
socket.on('r_gr_2', gr_2);
function gr_2(data){
console.log('grilletto 2');
$('.calx_gr').addClass('projected');
$('#grilletto').children('div').not('.calx_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 3
socket.on('r_gr_3', gr_3);
function gr_3(data){
console.log('grilletto 3');
$('.lime_gr').addClass('projected');
$('#grilletto').children('div').not('.lime_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 4
socket.on('r_gr_4', gr_4);
function gr_4(data){
console.log('grilletto 4');
$('.extramarine_gr').addClass('projected');
$('#grilletto').children('div').not('.extramarine_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 5
socket.on('r_gr_5', gr_5);
function gr_5(data){
console.log('grilletto 5');
$('.obsidian_gr').addClass('projected');
$('#grilletto').children('div').not('.obsidian_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 6
socket.on('r_gr_6', gr_6);
function gr_6(data){
console.log('grilletto 6');
$('.white_gr').addClass('projected');
$('#grilletto').children('div').not('.white_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 7
socket.on('r_gr_7', gr_7);
function gr_7(data){
console.log('grilletto 7');
$('.orange_gr').addClass('projected');
$('#grilletto').children('div').not('.orange_gr').removeClass('projected'); // remove Class from other parts
};
//grilletto 8
socket.on('r_gr_8', gr_8);
function gr_8(data){
console.log('grilletto 8');
$('.fuck_gr').addClass('projected');
$('#grilletto').children('div').not('.fuck_gr').removeClass('projected'); // remove Class from other parts
};
//dettagli 1
socket.on('r_de_1', de_1);
function de_1(data){
console.log('dettagli 1');
$('.magenta_de').addClass('projected');
$('#dettagli').children('div').not('.magenta_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 2
socket.on('r_de_2', de_2);
function de_2(data){
console.log('dettagli 2');
$('.calx_de').addClass('projected');
$('#dettagli').children('div').not('.calx_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 3
socket.on('r_de_3', de_3);
function de_3(data){
console.log('dettagli 3');
$('.lime_de').addClass('projected');
$('#dettagli').children('div').not('.lime_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 4
socket.on('r_de_4', de_4);
function de_4(data){
console.log('dettagli 4');
$('.extramarine_de').addClass('projected');
$('#dettagli').children('div').not('.extramarine_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 5
socket.on('r_de_5', de_5);
function de_5(data){
console.log('dettagli 5');
$('.obsidian_de').addClass('projected');
$('#dettagli').children('div').not('.obsidian_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 6
socket.on('r_de_6', de_6);
function de_6(data){
console.log('dettagli 6');
$('.white_de').addClass('projected');
$('#dettagli').children('div').not('.white_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 7
socket.on('r_de_7', de_7);
function de_7(data){
console.log('dettagli 7');
$('.orange_de').addClass('projected');
$('#dettagli').children('div').not('.orange_de').removeClass('projected'); // remove Class from other parts
};
//dettagli 8
socket.on('r_de_8', de_8);
function de_8(data){
console.log('dettagli 8');
$('.fuck_de').addClass('projected');
$('#dettagli').children('div').not('.fuck_de').removeClass('projected'); // remove Class from other parts
}; |
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
require "../../library/config.php";
require "../../library/functions.php";
require "../function/tools.php";
function updateConfig($config_name, $value="", $id_employee=0){
if($value !=""){
dbQuery("UPDATE tbl_config SET value='$value', id_employee='id_employee' WHERE config_name = '$config_name'");
return true;
}else{
return false;
}
}
if(isset($_GET['config'])&&isset($_GET['em'])){
$id_employee = $_GET['em'];
$role = $_POST['form_role'];
if($role =="general"){
$company = $_POST['company'];
$brand = $_POST['brand'];
$address = $_POST['company_address'];
$post_code = $_POST['post_code'];
$phone = $_POST['phone'];
$fax = $_POST['fax'];
$tax_id = $_POST['tax_id'];
$email = $_POST['email'];
$url = $_POST['home_page'];
$barcode_type = $_POST['barcode_type'];
$allow_under_zero = $_POST['allow_under_zero'];
$view_order_in_days = $_POST['view_order_in_days'];
$payment_detail = $_POST['payment_detail'];
$email_to_neworder = $_POST['email_to_neworder'];
updateConfig("EMAIL_TO_NEW_ORDER",$email_to_neworder, $id_employee);
updateConfig("COMPANY_FULL_NAME",$company, $id_employee);
updateConfig("COMPANY_NAME",$brand, $id_employee);
updateConfig("COMPANY_ADDRESS",$address, $id_employee);
updateConfig("COMPANY_POST_CODE",$post_code, $id_employee);
updateConfig("COMPANY_PHONE",$phone, $id_employee);
updateConfig("COMPANY_FAX_NUMBER",$fax, $id_employee);
updateConfig("COMPANY_TAX_ID",$tax_id, $id_employee);
updateConfig("COMPANY_EMAIL",$email, $id_employee);
updateConfig("HOME_PAGE_URL",$url, $id_employee);
updateConfig("BARCODE_TYPE",$barcode_type, $id_employee);
updateConfig("ALLOW_UNDER_ZERO",$allow_under_zero, $id_employee);
updateConfig("VIEW_ORDER_IN_DAYS",$view_order_in_days, $id_employee);
updateConfig("PAYMENT",$payment_detail, $id_employee);
$message = base64_encode("ปรับปรุงการตั้งค่าแล้ว");
header("location: ../index.php?content=config&general&message=$message");
}else if($rol
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 |
<?php
require "../../library/config.php";
require "../../library/functions.php";
require "../function/tools.php";
function updateConfig($config_name, $value="", $id_employee=0){
if($value !=""){
dbQuery("UPDATE tbl_config SET value='$value', id_employee='id_employee' WHERE config_name = '$config_name'");
return true;
}else{
return false;
}
}
if(isset($_GET['config'])&&isset($_GET['em'])){
$id_employee = $_GET['em'];
$role = $_POST['form_role'];
if($role =="general"){
$company = $_POST['company'];
$brand = $_POST['brand'];
$address = $_POST['company_address'];
$post_code = $_POST['post_code'];
$phone = $_POST['phone'];
$fax = $_POST['fax'];
$tax_id = $_POST['tax_id'];
$email = $_POST['email'];
$url = $_POST['home_page'];
$barcode_type = $_POST['barcode_type'];
$allow_under_zero = $_POST['allow_under_zero'];
$view_order_in_days = $_POST['view_order_in_days'];
$payment_detail = $_POST['payment_detail'];
$email_to_neworder = $_POST['email_to_neworder'];
updateConfig("EMAIL_TO_NEW_ORDER",$email_to_neworder, $id_employee);
updateConfig("COMPANY_FULL_NAME",$company, $id_employee);
updateConfig("COMPANY_NAME",$brand, $id_employee);
updateConfig("COMPANY_ADDRESS",$address, $id_employee);
updateConfig("COMPANY_POST_CODE",$post_code, $id_employee);
updateConfig("COMPANY_PHONE",$phone, $id_employee);
updateConfig("COMPANY_FAX_NUMBER",$fax, $id_employee);
updateConfig("COMPANY_TAX_ID",$tax_id, $id_employee);
updateConfig("COMPANY_EMAIL",$email, $id_employee);
updateConfig("HOME_PAGE_URL",$url, $id_employee);
updateConfig("BARCODE_TYPE",$barcode_type, $id_employee);
updateConfig("ALLOW_UNDER_ZERO",$allow_under_zero, $id_employee);
updateConfig("VIEW_ORDER_IN_DAYS",$view_order_in_days, $id_employee);
updateConfig("PAYMENT",$payment_detail, $id_employee);
$message = base64_encode("ปรับปรุงการตั้งค่าแล้ว");
header("location: ../index.php?content=config&general&message=$message");
}else if($role =="product"){
$new_product_date = $_POST['new_product_date'];
$new_product_qty = $_POST['new_product_qty'];
$features_product = $_POST['features_product'];
$max_show_stock = $_POST['max_show_stock'];
$vertical = $_POST['vertical'];
$horizontal = $_POST['horizontal'];
$additional = $_POST['additional'];
updateConfig("NEW_PRODUCT_DATE", $new_product_date, $id_employee);
updateConfig("FEATURES_PRODUCT", $features_product, $id_employee);
updateConfig("MAX_SHOW_STOCK",$max_show_stock , $id_employee);
updateConfig("NEW_PRODUCT_QTY",$new_product_qty, $id_employee);
updateConfig("ATTRIBUTE_GRID_VERTICAL",$vertical, $id_employee);
updateConfig("ATTRIBUTE_GRID_HORIZONTAL", $horizontal, $id_employee);
updateConfig("ATTRIBUTE_GRID_ADDITIONAL", $additional, $id_employee);
$message = base64_encode("ปรับปรุงการตั้งค่าแล้ว");
header("location: ../index.php?content=config&product&message=$message");
}else if($role =="document"){
$prefix_order = $_POST['prefix_order'];
$prefix_recieve = $_POST['prefix_recieve'];
$prefix_requisition = $_POST['prefix_requisition'];
$prefix_lend = $_POST['prefix_lend'];
$prefix_sponsor = $_POST['prefix_sponsor'];
$prefix_consignment = $_POST['prefix_consignment'];
$prefix_consign = $_POST['prefix_consign'];
$prefix_return = $_POST['prefix_return'];
updateConfig("PREFIX_ORDER",$prefix_order, $id_employee); /// ขาย
updateConfig("PREFIX_RECIEVE", $prefix_recieve, $id_employee); /// รับสินค้าเข้า
updateConfig("PREFIX_REQUISITION", $prefix_requisition, $id_employee); //เบิกสินค้า
updateConfig("PREFIX_LEND", $prefix_lend, $id_employee);//ยืมสินค้า
updateConfig("PREFIX_SPONSOR", $prefix_sponsor, $id_employee);///สปอนเซอร์
updateConfig("PREFIX_CONSIGNMENT", $prefix_consignment, $id_employee); //ฝากขาย
updateConfig("PREFIX_CONSIGN", $prefix_consign, $id_employee); //ตัดยอดฝากขาย
updateConfig("PREFIX_RETURN", $prefix_return, $id_employee);
$message = base64_encode("ปรับปรุงการตั้งค่าแล้ว");
header("location: ../index.php?content=config&document&message=$message");
}else if($role=="popup"){
$pop_on = $_POST['pop_on'];
$delay = $_POST['loop'];
$start = dbDate($_POST['from_date'])." 00:00:00";
if($start =="1970-01-01"){ $start = date('Y-m-d 00:00:00'); }
$end = dbDate($_POST['to_date'])." 23:59:59";
if($end =="1970-01-01"){ $end = date('Y-m-d 23:59:59',strtotime("+1 month")); }
$width = $_POST['width']; if($width =="" || $width ==0){ $width = 600; }
$height = $_POST['height']; if($height =="" || $width ==0){ $height = 600; }
$content = $_POST['content'];
$active = $_POST['active'];
if(isset($_POST['update_all'])){
$sql = "UPDATE tbl_popup SET delay = $delay, start ='$start', end = '$end', content = '$content', width ='$width', height ='$height', active ='$active'";
}else{
$sql = "UPDATE tbl_popup SET delay = $delay, start ='$start', end = '$end', content = '$content', width ='$width', height ='$height', active ='$active' WHERE pop_on = '$pop_on' ";
}
if(dbQuery($sql)){
$message = base64_encode("ปรับปรุงการตั้งค่าแล้ว");
header("location: ../index.php?content=config&popup=y&pop_on=$pop_on&message=$message");
}else{
$message = base64_encode("ปรับปรุงการตั้งค่าไม่สำเร็จ");
header("location: ../index.php?content=config&popup=y&pop_on=$pop_on&error=$message");
}
}else{
$message = base64_encode("ไม่สามารถปรับปรุงการตั้งค่าได้");
header("location: ../index.php?content=config&error=$message");
}
}
?> |
Below is an extract from a Ruby program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Ruby code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Ruby concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., metaprogramming, blocks). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Ruby. It should be similar to a school exercise, a tutorial, or a Ruby course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Ruby. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
class UserFollowing < ActiveRecord::Base
attr_accessible :followed_user
belongs_to :user
belongs_to :followed_user, class_name: 'User'
end
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| ruby | 2 | class UserFollowing < ActiveRecord::Base
attr_accessible :followed_user
belongs_to :user
belongs_to :followed_user, class_name: 'User'
end
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
SELECT tab7.v1 AS v1 , tab0.v0 AS v0 , tab8.v7 AS v7 , tab5.v5 AS v5 , tab6.v6 AS v6 , tab3.v4 AS v4 , tab1.v2 AS v2 , tab4.v8 AS v8
FROM (SELECT sub AS v1
FROM sorg__language$$8$$
WHERE obj = 'wsdbm:Language0'
) tab7
JOIN (SELECT obj AS v1 , sub AS v0
FROM foaf__homepage$$1$$
) tab0
ON(tab7.v1=tab0.v1)
JOIN (SELECT sub AS v0
FROM og__tag$$3$$
WHERE obj = 'wsdbm:Topic1'
) tab2
ON(tab0.v0=tab2.v0)
JOIN (SELECT sub AS v0 , obj AS v8
FROM sorg__contentSize$$5$$
) tab4
ON(tab2.v0=tab4.v0)
JOIN (SELECT sub AS v0 , obj AS v4
FROM sorg__description$$4$$
) tab3
ON(tab4.v0=tab3.v0)
JOIN (SELECT sub AS v1 , obj AS v5
FROM sorg__url$$6$$
) tab5
ON(tab0.v1=tab5.v1)
JOIN (SELECT sub AS v1 , obj AS v6
FROM wsdbm__hits$$7$$
) tab6
ON(tab5.v1=tab6.v1)
JOIN (SELECT obj AS v0 , sub AS v2
FROM gr__includes$$2$$
) tab1
ON(tab3.v0=tab1.v0)
JOIN (SELECT obj AS v0 , sub AS v7
FROM wsdbm__likes$$9$$
) tab8
ON(tab1.v0=tab8.v0)
++++++Tables Statistic
sorg__url$$6$$ 1 SO sorg__url/foaf__homepage
VP <sorg__url> 5000
SO <sorg__url><foaf__homepage> 4983 1.0
SS <sorg__url><wsdbm__hits> 5000 1.0
SS <sorg__url><sorg__language> 5000 1.0
------
sorg__contentSize$$5$$ 1 SS sorg__contentSize/foaf__homepage
VP <sorg__contentSize> 2438
SS <sorg__contentSize><foaf__homepage> 616 0.25
SO <sorg__contentSize><gr__includes> 2360 0.97
SS <sorg__contentSize><og__tag> 1436 0.59
SS <sorg__contentSize><sorg__description> 1448 0.59
SO <sorg__contentSize><wsdbm__likes> 2330 0.96
------
wsdbm__likes$$9$$ 4 OS wsdbm__likes/sorg__contentSize
VP <wsdbm__likes> 112401
OS <wsdbm__likes><foaf__homepage> 26377 0.23
OS <wsdbm__likes><og__tag> 64239 0.57
OS <wsdbm__likes><sorg__description> 69713 0.62
OS <wsdbm__likes><sorg__contentSize> 10190 0.09
------
og__tag$$3$$ 4 SS og__tag/sorg__contentSize
VP <og__tag> 147271
SS <og__tag><foaf__homepage> 36952 0.25
SO <og__tag><gr__includes> 142240 0.97
SS <og__tag><sor
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 3 | SELECT tab7.v1 AS v1 , tab0.v0 AS v0 , tab8.v7 AS v7 , tab5.v5 AS v5 , tab6.v6 AS v6 , tab3.v4 AS v4 , tab1.v2 AS v2 , tab4.v8 AS v8
FROM (SELECT sub AS v1
FROM sorg__language$$8$$
WHERE obj = 'wsdbm:Language0'
) tab7
JOIN (SELECT obj AS v1 , sub AS v0
FROM foaf__homepage$$1$$
) tab0
ON(tab7.v1=tab0.v1)
JOIN (SELECT sub AS v0
FROM og__tag$$3$$
WHERE obj = 'wsdbm:Topic1'
) tab2
ON(tab0.v0=tab2.v0)
JOIN (SELECT sub AS v0 , obj AS v8
FROM sorg__contentSize$$5$$
) tab4
ON(tab2.v0=tab4.v0)
JOIN (SELECT sub AS v0 , obj AS v4
FROM sorg__description$$4$$
) tab3
ON(tab4.v0=tab3.v0)
JOIN (SELECT sub AS v1 , obj AS v5
FROM sorg__url$$6$$
) tab5
ON(tab0.v1=tab5.v1)
JOIN (SELECT sub AS v1 , obj AS v6
FROM wsdbm__hits$$7$$
) tab6
ON(tab5.v1=tab6.v1)
JOIN (SELECT obj AS v0 , sub AS v2
FROM gr__includes$$2$$
) tab1
ON(tab3.v0=tab1.v0)
JOIN (SELECT obj AS v0 , sub AS v7
FROM wsdbm__likes$$9$$
) tab8
ON(tab1.v0=tab8.v0)
++++++Tables Statistic
sorg__url$$6$$ 1 SO sorg__url/foaf__homepage
VP <sorg__url> 5000
SO <sorg__url><foaf__homepage> 4983 1.0
SS <sorg__url><wsdbm__hits> 5000 1.0
SS <sorg__url><sorg__language> 5000 1.0
------
sorg__contentSize$$5$$ 1 SS sorg__contentSize/foaf__homepage
VP <sorg__contentSize> 2438
SS <sorg__contentSize><foaf__homepage> 616 0.25
SO <sorg__contentSize><gr__includes> 2360 0.97
SS <sorg__contentSize><og__tag> 1436 0.59
SS <sorg__contentSize><sorg__description> 1448 0.59
SO <sorg__contentSize><wsdbm__likes> 2330 0.96
------
wsdbm__likes$$9$$ 4 OS wsdbm__likes/sorg__contentSize
VP <wsdbm__likes> 112401
OS <wsdbm__likes><foaf__homepage> 26377 0.23
OS <wsdbm__likes><og__tag> 64239 0.57
OS <wsdbm__likes><sorg__description> 69713 0.62
OS <wsdbm__likes><sorg__contentSize> 10190 0.09
------
og__tag$$3$$ 4 SS og__tag/sorg__contentSize
VP <og__tag> 147271
SS <og__tag><foaf__homepage> 36952 0.25
SO <og__tag><gr__includes> 142240 0.97
SS <og__tag><sorg__description> 87737 0.6
SS <og__tag><sorg__contentSize> 14270 0.1
SO <og__tag><wsdbm__likes> 140021 0.95
------
sorg__language$$8$$ 1 SO sorg__language/foaf__homepage
VP <sorg__language> 6251
SO <sorg__language><foaf__homepage> 4983 0.8
SS <sorg__language><sorg__url> 5000 0.8
SS <sorg__language><wsdbm__hits> 5000 0.8
------
gr__includes$$2$$ 4 OS gr__includes/sorg__contentSize
VP <gr__includes> 90000
OS <gr__includes><foaf__homepage> 22529 0.25
OS <gr__includes><og__tag> 53879 0.6
OS <gr__includes><sorg__description> 53801 0.6
OS <gr__includes><sorg__contentSize> 8719 0.1
------
wsdbm__hits$$7$$ 1 SO wsdbm__hits/foaf__homepage
VP <wsdbm__hits> 5000
SO <wsdbm__hits><foaf__homepage> 4983 1.0
SS <wsdbm__hits><sorg__url> 5000 1.0
SS <wsdbm__hits><sorg__language> 5000 1.0
------
sorg__description$$4$$ 4 SS sorg__description/sorg__contentSize
VP <sorg__description> 14960
SS <sorg__description><foaf__homepage> 3760 0.25
SO <sorg__description><gr__includes> 14532 0.97
SS <sorg__description><og__tag> 8948 0.6
SS <sorg__description><sorg__contentSize> 1448 0.1
SO <sorg__description><wsdbm__likes> 14248 0.95
------
foaf__homepage$$1$$ 4 SS foaf__homepage/sorg__contentSize
VP <foaf__homepage> 11204
SO <foaf__homepage><gr__includes> 6095 0.54
SS <foaf__homepage><og__tag> 3739 0.33
SS <foaf__homepage><sorg__description> 3760 0.34
SS <foaf__homepage><sorg__contentSize> 616 0.05
OS <foaf__homepage><sorg__url> 11204 1.0
OS <foaf__homepage><wsdbm__hits> 11204 1.0
OS <foaf__homepage><sorg__language> 11204 1.0
SO <foaf__homepage><wsdbm__likes> 5961 0.53
------
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/* */
typedef struct two_fields{int one; int two[10];} tf_t;
int i[10];
tf_t s;
int *pi = &i[0];
tf_t *q = &s;
int global03()
{
int * p = i;
*pi = 1;
pi++;
q->one = 1;
q->two[4] = 2;
return *p;
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 3 | /* */
typedef struct two_fields{int one; int two[10];} tf_t;
int i[10];
tf_t s;
int *pi = &i[0];
tf_t *q = &s;
int global03()
{
int * p = i;
*pi = 1;
pi++;
q->one = 1;
q->two[4] = 2;
return *p;
}
|
Below is an extract from a shell script. Evaluate whether it has a high educational value and could help teach shell scripting. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the script contains valid shell commands, even if it's not educational, like simple system calls or basic file operations.
- Add another point if the script addresses practical shell scripting concepts (e.g., variables, conditionals), even if it lacks comments.
- Award a third point if the script is suitable for educational use and introduces key concepts in shell scripting, even if the topic is somewhat advanced (e.g., functions, process management). The script should be well-structured and contain some comments.
- Give a fourth point if the script is self-contained and highly relevant to teaching shell scripting. It should be similar to a tutorial example or a shell scripting course section, demonstrating good practices in script organization.
- Grant a fifth point if the script is outstanding in its educational value and is perfectly suited for teaching shell scripting. It should be well-written, easy to understand, and contain step-by-step explanations in comments.
The extract:
#!/bin/sh
# Descripion: This shell script used to choose a linux kernel version to cross compile
# Author: GuoWenxue<<EMAIL>>
# ChangeLog:
# 1, Version 1.0.0(2011.04.15), initialize first version
#
#User can pass a argument to specify which version should be cross compile
#or uncomment the DEF_VERSION variable to specify the version
DEF_VERSION=$1
#DEF_VERSION=linux-2.6.24
PWD=`pwd`
PACKET_DIR=$PWD/../packet
PATCH_DIR=$PWD/patch
PLATFORM=gr01
CPU=at91sam9260
ARCH=arm926ejs
PATCH_SUFFIX=-${PLATFORM}.patch
PRJ_NAME="linux kernel"
INST_PATH=$PWD/bin
SRC_NAME=
sup_ver=("" "linux-2.6.24" "linux-2.6.33" "linux-2.6.38")
#===============================================================
# Functions forward definition =
#===============================================================
function disp_banner()
{
echo ""
echo "+------------------------------------------+"
echo "| Build $PRJ_NAME for $PLATFORM "
echo "+------------------------------------------+"
echo ""
}
function select_version()
{
echo "Current support $PRJ_NAME version:"
i=1
len=${#sup_ver[*]}
while [ $i -lt $len ]; do
echo "$i: ${sup_ver[$i]}"
let i++;
done
echo "Please select: "
index=
read index
SRC_NAME=${sup_ver[$index]}
}
function disp_compile()
{
echo ""
echo "********************************************"
echo "* Cross compile $SRC_NAME now... "
echo "********************************************"
echo ""
}
#===============================================================
# Script excute body start =
#===============================================================
disp_banner #Display this shell script banner
# If not define default version, then let user choose a one
if [ -z $DEF_VERSION ] ; then
select_version
else
SRC_NAME=$DEF_VERSION
fi
# If $SRC_NAME not set, then abort this cross compile
if [ -z
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| shell | 4 | #!/bin/sh
# Descripion: This shell script used to choose a linux kernel version to cross compile
# Author: GuoWenxue<<EMAIL>>
# ChangeLog:
# 1, Version 1.0.0(2011.04.15), initialize first version
#
#User can pass a argument to specify which version should be cross compile
#or uncomment the DEF_VERSION variable to specify the version
DEF_VERSION=$1
#DEF_VERSION=linux-2.6.24
PWD=`pwd`
PACKET_DIR=$PWD/../packet
PATCH_DIR=$PWD/patch
PLATFORM=gr01
CPU=at91sam9260
ARCH=arm926ejs
PATCH_SUFFIX=-${PLATFORM}.patch
PRJ_NAME="linux kernel"
INST_PATH=$PWD/bin
SRC_NAME=
sup_ver=("" "linux-2.6.24" "linux-2.6.33" "linux-2.6.38")
#===============================================================
# Functions forward definition =
#===============================================================
function disp_banner()
{
echo ""
echo "+------------------------------------------+"
echo "| Build $PRJ_NAME for $PLATFORM "
echo "+------------------------------------------+"
echo ""
}
function select_version()
{
echo "Current support $PRJ_NAME version:"
i=1
len=${#sup_ver[*]}
while [ $i -lt $len ]; do
echo "$i: ${sup_ver[$i]}"
let i++;
done
echo "Please select: "
index=
read index
SRC_NAME=${sup_ver[$index]}
}
function disp_compile()
{
echo ""
echo "********************************************"
echo "* Cross compile $SRC_NAME now... "
echo "********************************************"
echo ""
}
#===============================================================
# Script excute body start =
#===============================================================
disp_banner #Display this shell script banner
# If not define default version, then let user choose a one
if [ -z $DEF_VERSION ] ; then
select_version
else
SRC_NAME=$DEF_VERSION
fi
# If $SRC_NAME not set, then abort this cross compile
if [ -z $SRC_NAME ] ; then
echo "ERROR: Please choose a valid version to cross compile"
exit 1;
fi
# Check original source code packet exist or not
SRC_ORIG_PACKET=$PACKET_DIR/$SRC_NAME.tar.bz2
if [ ! -s $SRC_ORIG_PACKET ] ; then
cd $PACKET_DIR
wget http://www.kernel.org/pub/linux/kernel/v2.6/$SRC_NAME.tar.bz2
cd -
fi
if [ ! -s $SRC_ORIG_PACKET ] ; then
echo ""
echo "ERROR:$PRJ_NAME source code patcket doesn't exist:"
echo "PATH: \"$SRC_ORIG_PACKET\""
echo ""
exit
fi
# Check patche file exist or not
PATCH_FILE=$SRC_NAME$PATCH_SUFFIX
PATCH_FILE_PATH=$PATCH_DIR/$PATCH_FILE
if [ ! -f $PATCH_FILE_PATH ] ; then
echo "ERROR:$PRJ_NAME patch file doesn't exist:"
echo "PATH: \"$PATCH_FILE_PATH\""
echo ""
exit
fi
#decompress the source code packet and patch
echo "* Decompress the source code patcket and patch now... *"
if [ -d $SRC_NAME ] ; then
rm -rf $SRC_NAME
fi
#Remove old source code
tar -xjf $SRC_ORIG_PACKET
cp $PATCH_FILE_PATH $SRC_NAME
#patch -p0 < $PATCH_FILE
#Start to cross compile the source code and install it now
disp_compile
cd $SRC_NAME
patch -p1 < $PATCH_FILE
rm -f $PATCH_FILE
cp .cfg-$PLATFORM .config
make
VERSION=`echo $SRC_NAME | awk -F "-" '{print $2}'`
cp arch/arm/boot/zImage . -f
mkimage -A arm -O linux -T kernel -C none -a 20008000 -e 20008000 -n "Linux Kernel" -d zImage uImage.gz
rm -f zImage
set -x
cp uImage.gz /tftpboot/uImage-$VERSION-$PLATFORM.gz --reply=yes
cp -af uImage.gz $INST_PATH/uImage-$VERSION-$PLATFORM.gz
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
using System.Runtime.CompilerServices;
using Imagin.Common;
using Imagin.Common.Models;
using Imagin.Common.Text;
using Imagin.Common.Threading;
namespace Text
{
public class ConvertPanel : Panel
{
bool destinationTextChangeHandled;
bool sourceTextChangeHandled;
readonly BackgroundQueue queue = new BackgroundQueue();
SymmetricAlgorithm algorithm;
public SymmetricAlgorithm Algorithm
{
get => algorithm;
set => this.Change(ref algorithm, value);
}
string destinationText;
public string DestinationText
{
get => destinationText;
set
{
this.Change(ref destinationText, value);
OnDestinationTextChanged(destinationText);
}
}
Encoding encoding;
public Encoding Encoding
{
get => encoding;
set => this.Change(ref encoding , value);
}
bool isDestinationTextInvalid = false;
public bool IsDestinationTextInvalid
{
get => isDestinationTextInvalid;
set => this.Change(ref isDestinationTextInvalid, value);
}
bool isSourceTextInvalid = false;
public bool IsSourceTextInvalid
{
get => isSourceTextInvalid;
set => this.Change(ref isSourceTextInvalid, value);
}
int maxLength = 10000;
public int MaxLength
{
get => maxLength;
set => this.Change(ref maxLength, value);
}
string password;
public string Password
{
get => password;
set => this.Change(ref password, value);
}
string sourceText;
public string SourceText
{
get => sourceText;
set
{
if (value?.Length > maxLength)
value = value.Substring(0, maxLength);
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 3 | using System.Runtime.CompilerServices;
using Imagin.Common;
using Imagin.Common.Models;
using Imagin.Common.Text;
using Imagin.Common.Threading;
namespace Text
{
public class ConvertPanel : Panel
{
bool destinationTextChangeHandled;
bool sourceTextChangeHandled;
readonly BackgroundQueue queue = new BackgroundQueue();
SymmetricAlgorithm algorithm;
public SymmetricAlgorithm Algorithm
{
get => algorithm;
set => this.Change(ref algorithm, value);
}
string destinationText;
public string DestinationText
{
get => destinationText;
set
{
this.Change(ref destinationText, value);
OnDestinationTextChanged(destinationText);
}
}
Encoding encoding;
public Encoding Encoding
{
get => encoding;
set => this.Change(ref encoding , value);
}
bool isDestinationTextInvalid = false;
public bool IsDestinationTextInvalid
{
get => isDestinationTextInvalid;
set => this.Change(ref isDestinationTextInvalid, value);
}
bool isSourceTextInvalid = false;
public bool IsSourceTextInvalid
{
get => isSourceTextInvalid;
set => this.Change(ref isSourceTextInvalid, value);
}
int maxLength = 10000;
public int MaxLength
{
get => maxLength;
set => this.Change(ref maxLength, value);
}
string password;
public string Password
{
get => password;
set => this.Change(ref password, value);
}
string sourceText;
public string SourceText
{
get => sourceText;
set
{
if (value?.Length > maxLength)
value = value.Substring(0, maxLength);
this.Change(ref sourceText, value);
OnSourceTextChanged(sourceText);
}
}
public override string Title => "Convert";
public ConvertPanel() : base(Resources.Uri(nameof(Text), "/Images/Key.png")) { }
public override void OnPropertyChanged([CallerMemberName] string propertyName = "")
{
base.OnPropertyChanged(propertyName);
switch (propertyName)
{
case nameof(Algorithm):
case nameof(Encoding):
case nameof(Password):
OnSourceTextChanged(sourceText);
break;
}
}
void OnDestinationTextChanged(string destinationText)
{
if (!destinationTextChangeHandled)
{
queue.Add(() =>
{
sourceTextChangeHandled = true;
var resultText = destinationText;
var result = Converter.TryDecryptText(ref resultText, destinationText, Password, Algorithm, Encoding);
if (!result)
{
IsDestinationTextInvalid = true;
}
else
{
IsDestinationTextInvalid = false;
IsSourceTextInvalid = false;
}
SourceText = resultText;
sourceTextChangeHandled = false;
});
}
}
void OnSourceTextChanged(string sourceText)
{
if (!sourceTextChangeHandled)
{
queue.Add(() =>
{
destinationTextChangeHandled = true;
var resultText = sourceText;
var result = Converter.TryEncryptText(ref resultText, sourceText, Password, Algorithm, Encoding);
if (!result)
{
IsSourceTextInvalid = true;
}
else
{
IsDestinationTextInvalid = false;
IsSourceTextInvalid = false;
}
DestinationText = resultText;
destinationTextChangeHandled = false;
});
}
}
}
} |
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
#![allow(dead_code)]
#![allow(unused_imports)]
extern crate byteorder;
extern crate speexdsp;
extern crate structopt;
use byteorder::{BigEndian, ByteOrder};
use std::fs::File;
use std::io::{Read, Write};
use std::path::PathBuf;
use structopt::StructOpt;
#[derive(Debug, StructOpt)]
struct CliArgs {
#[structopt(parse(from_os_str))]
echo_fd_path: PathBuf,
#[structopt(parse(from_os_str))]
ref_fd_path: PathBuf,
#[structopt(parse(from_os_str))]
e_fd_path: PathBuf,
}
#[cfg(feature = "sys")]
fn main() -> std::io::Result<()> {
use speexdsp::echo::SpeexEchoConst::*;
use speexdsp::echo::*;
use speexdsp::preprocess::SpeexPreprocessConst::*;
use speexdsp::preprocess::*;
const NN: usize = 160;
const TAIL: usize = 1024;
let sample_rate: usize = 8000;
let mut echo_buf: [i16; NN] = [0; NN];
let mut echo_read_buf: [u8; NN * 2] = [0; NN * 2];
let mut ref_buf: [i16; NN] = [0; NN];
let mut ref_read_buf: [u8; NN * 2] = [0; NN * 2];
let mut e_buf: [i16; NN] = [0; NN];
let opts = CliArgs::from_args();
let mut ref_fd = File::open(opts.ref_fd_path)?;
let mut echo_fd = File::open(opts.echo_fd_path)?;
let mut e_fd = File::create(opts.e_fd_path)?;
let mut st = SpeexEcho::new(NN, TAIL).unwrap();
let mut den = SpeexPreprocess::new(NN, sample_rate).unwrap();
st.echo_ctl(SPEEX_ECHO_SET_SAMPLING_RATE, sample_rate)
.unwrap();
den.preprocess_ctl(SPEEX_PREPROCESS_SET_ECHO_STATE, &st)
.unwrap();
loop {
let n = echo_fd.read(&mut echo_read_buf)?;
let nn = ref_fd.read(&mut ref_read_buf)?;
if n == 0 && nn == 0 {
break;
}
BigEndian::read_i16_into(&echo_read_buf, &mut echo_buf);
BigEndian::read_i16_into(&ref_read_buf, &mut ref_buf);
st.echo_cancellation(&ref_buf, &echo_buf, &mut e_buf);
den.preprocess_run(&mut e_buf);
BigEndian::write_i16_into(&e_buf, &mut ref_read_buf);
e_fd.write_all(&
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | #![allow(dead_code)]
#![allow(unused_imports)]
extern crate byteorder;
extern crate speexdsp;
extern crate structopt;
use byteorder::{BigEndian, ByteOrder};
use std::fs::File;
use std::io::{Read, Write};
use std::path::PathBuf;
use structopt::StructOpt;
#[derive(Debug, StructOpt)]
struct CliArgs {
#[structopt(parse(from_os_str))]
echo_fd_path: PathBuf,
#[structopt(parse(from_os_str))]
ref_fd_path: PathBuf,
#[structopt(parse(from_os_str))]
e_fd_path: PathBuf,
}
#[cfg(feature = "sys")]
fn main() -> std::io::Result<()> {
use speexdsp::echo::SpeexEchoConst::*;
use speexdsp::echo::*;
use speexdsp::preprocess::SpeexPreprocessConst::*;
use speexdsp::preprocess::*;
const NN: usize = 160;
const TAIL: usize = 1024;
let sample_rate: usize = 8000;
let mut echo_buf: [i16; NN] = [0; NN];
let mut echo_read_buf: [u8; NN * 2] = [0; NN * 2];
let mut ref_buf: [i16; NN] = [0; NN];
let mut ref_read_buf: [u8; NN * 2] = [0; NN * 2];
let mut e_buf: [i16; NN] = [0; NN];
let opts = CliArgs::from_args();
let mut ref_fd = File::open(opts.ref_fd_path)?;
let mut echo_fd = File::open(opts.echo_fd_path)?;
let mut e_fd = File::create(opts.e_fd_path)?;
let mut st = SpeexEcho::new(NN, TAIL).unwrap();
let mut den = SpeexPreprocess::new(NN, sample_rate).unwrap();
st.echo_ctl(SPEEX_ECHO_SET_SAMPLING_RATE, sample_rate)
.unwrap();
den.preprocess_ctl(SPEEX_PREPROCESS_SET_ECHO_STATE, &st)
.unwrap();
loop {
let n = echo_fd.read(&mut echo_read_buf)?;
let nn = ref_fd.read(&mut ref_read_buf)?;
if n == 0 && nn == 0 {
break;
}
BigEndian::read_i16_into(&echo_read_buf, &mut echo_buf);
BigEndian::read_i16_into(&ref_read_buf, &mut ref_buf);
st.echo_cancellation(&ref_buf, &echo_buf, &mut e_buf);
den.preprocess_run(&mut e_buf);
BigEndian::write_i16_into(&e_buf, &mut ref_read_buf);
e_fd.write_all(&ref_read_buf)?;
}
Ok(())
}
#[cfg(not(feature = "sys"))]
fn main() {
unimplemented!();
}
|
Below is an extract from a shell script. Evaluate whether it has a high educational value and could help teach shell scripting. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the script contains valid shell commands, even if it's not educational, like simple system calls or basic file operations.
- Add another point if the script addresses practical shell scripting concepts (e.g., variables, conditionals), even if it lacks comments.
- Award a third point if the script is suitable for educational use and introduces key concepts in shell scripting, even if the topic is somewhat advanced (e.g., functions, process management). The script should be well-structured and contain some comments.
- Give a fourth point if the script is self-contained and highly relevant to teaching shell scripting. It should be similar to a tutorial example or a shell scripting course section, demonstrating good practices in script organization.
- Grant a fifth point if the script is outstanding in its educational value and is perfectly suited for teaching shell scripting. It should be well-written, easy to understand, and contain step-by-step explanations in comments.
The extract:
export JAVA_HOME=/Program Files/Java/jdk1.8.0_111
cd /Android/workspace/Residency4Rent
jarsigner -verify -verbose -certs /Android/workspace/Residency4Rent/bin/Residency4Rent-release.apk
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| shell | 1 | export JAVA_HOME=/Program Files/Java/jdk1.8.0_111
cd /Android/workspace/Residency4Rent
jarsigner -verify -verbose -certs /Android/workspace/Residency4Rent/bin/Residency4Rent-release.apk
|
Below is an extract from a shell script. Evaluate whether it has a high educational value and could help teach shell scripting. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the script contains valid shell commands, even if it's not educational, like simple system calls or basic file operations.
- Add another point if the script addresses practical shell scripting concepts (e.g., variables, conditionals), even if it lacks comments.
- Award a third point if the script is suitable for educational use and introduces key concepts in shell scripting, even if the topic is somewhat advanced (e.g., functions, process management). The script should be well-structured and contain some comments.
- Give a fourth point if the script is self-contained and highly relevant to teaching shell scripting. It should be similar to a tutorial example or a shell scripting course section, demonstrating good practices in script organization.
- Grant a fifth point if the script is outstanding in its educational value and is perfectly suited for teaching shell scripting. It should be well-written, easy to understand, and contain step-by-step explanations in comments.
The extract:
cat log/adbs.log | grep ICAO | awk '{split($0,a,":"); print a[2]}' | sort | uniq
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| shell | 3 | cat log/adbs.log | grep ICAO | awk '{split($0,a,":"); print a[2]}' | sort | uniq
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use crate::{errors::ParseError, line_parser::LineParser, Action};
/// Represents a line in the rebase file.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Line {
action: Action,
content: String,
hash: String,
mutated: bool,
option: Option<String>,
}
impl Line {
/// Create a new noop line.
#[must_use]
const fn new_noop() -> Self {
Self {
action: Action::Noop,
content: String::new(),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new pick line.
#[must_use]
#[inline]
pub fn new_pick(hash: &str) -> Self {
Self {
action: Action::Pick,
content: String::new(),
hash: String::from(hash),
mutated: false,
option: None,
}
}
/// Create a new break line.
#[must_use]
#[inline]
pub const fn new_break() -> Self {
Self {
action: Action::Break,
content: String::new(),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new exec line.
#[must_use]
#[inline]
pub fn new_exec(command: &str) -> Self {
Self {
action: Action::Exec,
content: String::from(command),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new merge line.
#[must_use]
#[inline]
pub fn new_merge(command: &str) -> Self {
Self {
action: Action::Merge,
content: String::from(command),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new label line.
#[must_use]
#[inline]
pub fn new_label(label: &str) -> Self {
Self {
action: Action::Label,
content: String::from(label),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new reset line.
#[must_use]
#[inline]
pub fn new_reset(label: &str) -> Self {
Self {
action: Action::Reset,
content: String::from(label),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new update-ref line.
#[must_use]
#[inline]
pub fn new_update_ref(ref_name: &str) -> Self {
Self {
action: Action::UpdateRef,
c
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | use crate::{errors::ParseError, line_parser::LineParser, Action};
/// Represents a line in the rebase file.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Line {
action: Action,
content: String,
hash: String,
mutated: bool,
option: Option<String>,
}
impl Line {
/// Create a new noop line.
#[must_use]
const fn new_noop() -> Self {
Self {
action: Action::Noop,
content: String::new(),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new pick line.
#[must_use]
#[inline]
pub fn new_pick(hash: &str) -> Self {
Self {
action: Action::Pick,
content: String::new(),
hash: String::from(hash),
mutated: false,
option: None,
}
}
/// Create a new break line.
#[must_use]
#[inline]
pub const fn new_break() -> Self {
Self {
action: Action::Break,
content: String::new(),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new exec line.
#[must_use]
#[inline]
pub fn new_exec(command: &str) -> Self {
Self {
action: Action::Exec,
content: String::from(command),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new merge line.
#[must_use]
#[inline]
pub fn new_merge(command: &str) -> Self {
Self {
action: Action::Merge,
content: String::from(command),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new label line.
#[must_use]
#[inline]
pub fn new_label(label: &str) -> Self {
Self {
action: Action::Label,
content: String::from(label),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new reset line.
#[must_use]
#[inline]
pub fn new_reset(label: &str) -> Self {
Self {
action: Action::Reset,
content: String::from(label),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new update-ref line.
#[must_use]
#[inline]
pub fn new_update_ref(ref_name: &str) -> Self {
Self {
action: Action::UpdateRef,
content: String::from(ref_name),
hash: String::new(),
mutated: false,
option: None,
}
}
/// Create a new line from a rebase file line.
///
/// # Errors
///
/// Returns an error if an invalid line is provided.
#[inline]
pub fn new(input_line: &str) -> Result<Self, ParseError> {
let mut line_parser = LineParser::new(input_line);
let action = Action::try_from(line_parser.next()?)?;
Ok(match action {
Action::Noop => Self::new_noop(),
Action::Break => Self::new_break(),
Action::Pick | Action::Reword | Action::Edit | Action::Squash | Action::Drop => {
let hash = String::from(line_parser.next()?);
Self {
action,
hash,
content: String::from(line_parser.take_remaining()),
mutated: false,
option: None,
}
},
Action::Fixup => {
let mut next = line_parser.next()?;
let option = if next.starts_with('-') {
let opt = String::from(next);
next = line_parser.next()?;
Some(opt)
}
else {
None
};
let hash = String::from(next);
Self {
action,
hash,
content: String::from(line_parser.take_remaining()),
mutated: false,
option,
}
},
Action::Exec | Action::Merge | Action::Label | Action::Reset | Action::UpdateRef => {
if !line_parser.has_more() {
return Err(line_parser.parse_error());
}
Self {
action,
hash: String::new(),
content: String::from(line_parser.take_remaining()),
mutated: false,
option: None,
}
},
})
}
/// Set the action of the line.
#[inline]
pub fn set_action(&mut self, action: Action) {
if !self.action.is_static() && self.action != action {
self.mutated = true;
self.action = action;
self.option = None;
}
}
/// Edit the content of the line, if it is editable.
#[inline]
pub fn edit_content(&mut self, content: &str) {
if self.is_editable() {
self.content = String::from(content);
}
}
/// Set the option on the line, toggling if the existing option matches.
#[inline]
pub fn toggle_option(&mut self, option: &str) {
// try toggle off first
if let Some(current) = self.option.as_deref() {
if current == option {
self.option = None;
return;
}
}
self.option = Some(String::from(option));
}
/// Get the action of the line.
#[must_use]
#[inline]
pub const fn get_action(&self) -> &Action {
&self.action
}
/// Get the content of the line.
#[must_use]
#[inline]
pub fn get_content(&self) -> &str {
self.content.as_str()
}
/// Get the commit hash for the line.
#[must_use]
#[inline]
pub fn get_hash(&self) -> &str {
self.hash.as_str()
}
/// Get the commit hash for the line.
#[must_use]
#[inline]
pub fn option(&self) -> Option<&str> {
self.option.as_deref()
}
/// Does this line contain a commit reference.
#[must_use]
#[inline]
pub fn has_reference(&self) -> bool {
!self.hash.is_empty()
}
/// Can this line be edited.
#[must_use]
#[inline]
pub const fn is_editable(&self) -> bool {
match self.action {
Action::Exec | Action::Label | Action::Reset | Action::Merge | Action::UpdateRef => true,
Action::Break
| Action::Drop
| Action::Edit
| Action::Fixup
| Action::Noop
| Action::Pick
| Action::Reword
| Action::Squash => false,
}
}
/// Create a string containing a textual version of the line, as would be seen in the rebase file.
#[must_use]
#[inline]
pub fn to_text(&self) -> String {
match self.action {
Action::Drop | Action::Edit | Action::Fixup | Action::Pick | Action::Reword | Action::Squash => {
if let Some(opt) = self.option.as_ref() {
format!("{} {opt} {} {}", self.action, self.hash, self.content)
}
else {
format!("{} {} {}", self.action, self.hash, self.content)
}
},
Action::Exec | Action::Label | Action::Reset | Action::Merge | Action::UpdateRef => {
format!("{} {}", self.action, self.content)
},
Action::Noop | Action::Break => self.action.to_string(),
}
}
}
#[cfg(test)]
mod tests {
use claim::assert_ok_eq;
use rstest::rstest;
use testutils::assert_err_eq;
use super::*;
#[rstest]
#[case::pick_action("pick aaa comment", &Line {
action: Action::Pick,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::reword_action("reword aaa comment", &Line {
action: Action::Reword,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::edit_action("edit aaa comment", &Line {
action: Action::Edit,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::squash_action("squash aaa comment", &Line {
action: Action::Squash,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::fixup_action("fixup aaa comment", &Line {
action: Action::Fixup,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::fixup_with_option_action("fixup -c aaa comment", &Line {
action: Action::Fixup,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: Some(String::from("-c")),
})]
#[case::drop_action("drop aaa comment", &Line {
action: Action::Drop,
hash: String::from("aaa"),
content: String::from("comment"),
mutated: false,
option: None,
})]
#[case::action_without_comment("pick aaa", &Line {
action: Action::Pick,
hash: String::from("aaa"),
content: String::new(),
mutated: false,
option: None,
})]
#[case::exec_action("exec command", &Line {
action: Action::Exec,
hash: String::new(),
content: String::from("command"),
mutated: false,
option: None,
})]
#[case::label_action("label ref", &Line {
action: Action::Label,
hash: String::new(),
content: String::from("ref"),
mutated: false,
option: None,
})]
#[case::reset_action("reset ref", &Line {
action: Action::Reset,
hash: String::new(),
content: String::from("ref"),
mutated: false,
option: None,
})]
#[case::reset_action("merge command", &Line {
action: Action::Merge,
hash: String::new(),
content: String::from("command"),
mutated: false,
option: None,
})]
#[case::update_ref_action("update-ref reference", &Line {
action: Action::UpdateRef,
hash: String::new(),
content: String::from("reference"),
mutated: false,
option: None,
})]
#[case::break_action("break", &Line {
action: Action::Break,
hash: String::new(),
content: String::new(),
mutated: false,
option: None,
})]
#[case::nnop( "noop", &Line {
action: Action::Noop,
hash: String::new(),
content: String::new(),
mutated: false,
option: None,
})]
fn new(#[case] line: &str, #[case] expected: &Line) {
assert_ok_eq!(&Line::new(line), expected);
}
#[test]
fn line_new_pick() {
assert_eq!(Line::new_pick("abc123"), Line {
action: Action::Pick,
hash: String::from("abc123"),
content: String::new(),
mutated: false,
option: None,
});
}
#[test]
fn line_new_break() {
assert_eq!(Line::new_break(), Line {
action: Action::Break,
hash: String::new(),
content: String::new(),
mutated: false,
option: None,
});
}
#[test]
fn line_new_exec() {
assert_eq!(Line::new_exec("command"), Line {
action: Action::Exec,
hash: String::new(),
content: String::from("command"),
mutated: false,
option: None,
});
}
#[test]
fn line_new_merge() {
assert_eq!(Line::new_merge("command"), Line {
action: Action::Merge,
hash: String::new(),
content: String::from("command"),
mutated: false,
option: None,
});
}
#[test]
fn line_new_label() {
assert_eq!(Line::new_label("label"), Line {
action: Action::Label,
hash: String::new(),
content: String::from("label"),
mutated: false,
option: None,
});
}
#[test]
fn line_new_reset() {
assert_eq!(Line::new_reset("label"), Line {
action: Action::Reset,
hash: String::new(),
content: String::from("label"),
mutated: false,
option: None,
});
}
#[test]
fn line_new_update_ref() {
assert_eq!(Line::new_update_ref("reference"), Line {
action: Action::UpdateRef,
hash: String::new(),
content: String::from("reference"),
mutated: false,
option: None,
});
}
#[test]
fn new_err_invalid_action() {
assert_err_eq!(
Line::new("invalid aaa comment"),
ParseError::InvalidAction(String::from("invalid"))
);
}
#[rstest]
#[case::pick_line_only("pick")]
#[case::reword_line_only("reword")]
#[case::edit_line_only("edit")]
#[case::squash_line_only("squash")]
#[case::fixup_line_only("fixup")]
#[case::exec_line_only("exec")]
#[case::drop_line_only("drop")]
#[case::label_line_only("label")]
#[case::reset_line_only("reset")]
#[case::merge_line_only("merge")]
#[case::update_ref_line_only("update-ref")]
fn new_err(#[case] line: &str) {
assert_err_eq!(Line::new(line), ParseError::InvalidLine(String::from(line)));
}
#[rstest]
#[case::drop(Action::Drop, Action::Fixup)]
#[case::edit(Action::Edit, Action::Fixup)]
#[case::fixup(Action::Fixup, Action::Pick)]
#[case::pick(Action::Pick, Action::Fixup)]
#[case::reword(Action::Reword, Action::Fixup)]
#[case::squash(Action::Squash, Action::Fixup)]
fn set_action_non_static(#[case] from: Action, #[case] to: Action) {
let mut line = Line::new(format!("{from} aaa bbb").as_str()).unwrap();
line.set_action(to);
assert_eq!(line.action, to);
assert!(line.mutated);
}
#[rstest]
#[case::break_action(Action::Break, Action::Fixup)]
#[case::label_action(Action::Label, Action::Fixup)]
#[case::reset_action(Action::Reset, Action::Fixup)]
#[case::merge_action(Action::Merge, Action::Fixup)]
#[case::exec(Action::Exec, Action::Fixup)]
#[case::update_ref(Action::UpdateRef, Action::Fixup)]
#[case::noop(Action::Noop, Action::Fixup)]
fn set_action_static(#[case] from: Action, #[case] to: Action) {
let mut line = Line::new(format!("{from} comment").as_str()).unwrap();
line.set_action(to);
assert_eq!(line.action, from);
assert!(!line.mutated);
}
#[test]
fn set_to_new_action_with_changed_action() {
let mut line = Line::new("pick aaa comment").unwrap();
line.set_action(Action::Fixup);
assert_eq!(line.action, Action::Fixup);
assert!(line.mutated);
}
#[test]
fn set_to_new_action_with_unchanged_action() {
let mut line = Line::new("pick aaa comment").unwrap();
line.set_action(Action::Pick);
assert_eq!(line.action, Action::Pick);
assert!(!line.mutated);
}
#[rstest]
#[case::break_action("break", "")]
#[case::drop("drop aaa comment", "comment")]
#[case::edit("edit aaa comment", "comment")]
#[case::exec("exec git commit --amend 'foo'", "new")]
#[case::fixup("fixup aaa comment", "comment")]
#[case::pick("pick aaa comment", "comment")]
#[case::reword("reword aaa comment", "comment")]
#[case::squash("squash aaa comment", "comment")]
#[case::label("label ref", "new")]
#[case::reset("reset ref", "new")]
#[case::merge("merge command", "new")]
#[case::update_ref("update-ref reference", "new")]
fn edit_content(#[case] line: &str, #[case] expected: &str) {
let mut line = Line::new(line).unwrap();
line.edit_content("new");
assert_eq!(line.get_content(), expected);
}
#[rstest]
#[case::break_action("break", "")]
#[case::drop("drop aaa comment", "comment")]
#[case::edit("edit aaa comment", "comment")]
#[case::exec("exec git commit --amend 'foo'", "git commit --amend 'foo'")]
#[case::fixup("fixup aaa comment", "comment")]
#[case::pick("pick aaa comment", "comment")]
#[case::reword("reword aaa comment", "comment")]
#[case::squash("squash aaa comment", "comment")]
#[case::label("label reference", "reference")]
#[case::reset("reset reference", "reference")]
#[case::merge("merge command", "command")]
#[case::update_ref("update-ref reference", "reference")]
fn get_content(#[case] line: &str, #[case] expected: &str) {
assert_eq!(Line::new(line).unwrap().get_content(), expected);
}
#[rstest]
#[case::break_action("break", Action::Break)]
#[case::drop("drop aaa comment", Action::Drop)]
#[case::edit("edit aaa comment", Action::Edit)]
#[case::exec("exec git commit --amend 'foo'", Action::Exec)]
#[case::fixup("fixup aaa comment", Action::Fixup)]
#[case::pick("pick aaa comment", Action::Pick)]
#[case::reword("reword aaa comment", Action::Reword)]
#[case::squash("squash aaa comment", Action::Squash)]
#[case::label("label reference", Action::Label)]
#[case::reset("reset reference", Action::Reset)]
#[case::merge("merge command", Action::Merge)]
#[case::update_ref("update-ref reference", Action::UpdateRef)]
fn get_action(#[case] line: &str, #[case] expected: Action) {
assert_eq!(Line::new(line).unwrap().get_action(), &expected);
}
#[rstest]
#[case::break_action("break", "")]
#[case::drop("drop aaa comment", "aaa")]
#[case::edit("edit aaa comment", "aaa")]
#[case::exec("exec git commit --amend 'foo'", "")]
#[case::fixup("fixup aaa comment", "aaa")]
#[case::pick("pick aaa comment", "aaa")]
#[case::reword("reword aaa comment", "aaa")]
#[case::squash("squash aaa comment", "aaa")]
#[case::label("label reference", "")]
#[case::reset("reset reference", "")]
#[case::merge("merge command", "")]
#[case::update_ref("update-ref reference", "")]
fn get_hash(#[case] line: &str, #[case] expected: &str) {
assert_eq!(Line::new(line).unwrap().get_hash(), expected);
}
#[rstest]
#[case::break_action("break", false)]
#[case::drop("drop aaa comment", true)]
#[case::edit("edit aaa comment", true)]
#[case::exec("exec git commit --amend 'foo'", false)]
#[case::fixup("fixup aaa comment", true)]
#[case::pick("pick aaa comment", true)]
#[case::reword("reword aaa comment", true)]
#[case::squash("squash aaa comment", true)]
#[case::label("label ref", false)]
#[case::reset("reset ref", false)]
#[case::merge("merge command", false)]
#[case::update_ref("update-ref reference", false)]
fn has_reference(#[case] line: &str, #[case] expected: bool) {
assert_eq!(Line::new(line).unwrap().has_reference(), expected);
}
#[rstest]
#[case::drop(Action::Break, false)]
#[case::drop(Action::Drop, false)]
#[case::edit(Action::Edit, false)]
#[case::exec(Action::Exec, true)]
#[case::fixup(Action::Fixup, false)]
#[case::pick(Action::Noop, false)]
#[case::pick(Action::Pick, false)]
#[case::reword(Action::Reword, false)]
#[case::squash(Action::Squash, false)]
#[case::label(Action::Label, true)]
#[case::reset(Action::Reset, true)]
#[case::merge(Action::Merge, true)]
#[case::update_ref(Action::UpdateRef, true)]
fn is_editable(#[case] from: Action, #[case] editable: bool) {
let line = Line::new(format!("{from} aaa bbb").as_str()).unwrap();
assert_eq!(line.is_editable(), editable);
}
#[rstest]
#[case::break_action("break")]
#[case::drop("drop aaa comment")]
#[case::edit("edit aaa comment")]
#[case::exec("exec git commit --amend 'foo'")]
#[case::fixup("fixup aaa comment")]
#[case::fixup_with_options("fixup -c aaa comment")]
#[case::pick("pick aaa comment")]
#[case::reword("reword aaa comment")]
#[case::squash("squash aaa comment")]
#[case::label("label reference")]
#[case::reset("reset reference")]
#[case::merge("merge command")]
#[case::update_ref("update-ref reference")]
fn to_text(#[case] line: &str) {
assert_eq!(Line::new(line).unwrap().to_text(), line);
}
}
|
Below is an extract from a Swift program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Swift code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Swift concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., protocols, extensions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Swift. It should be similar to a school exercise, a tutorial, or a Swift course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Swift. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//
// DetailModel.swift
// UIMaster
//
// Created by hobson on 2018/7/31.
// Copyright © 2018年 one2much. All rights reserved.
//
import Foundation
// swiftlint:disable identifier_name
class DetailModel: BaseModel {
var data: DetailData?
}
class DetailData: BaseData {
var add_time: String!
var address: String!
var all_val_num: Int!
var area_id: Int!
var attachment: Int!
var attachment_download: Int!
var attachment_size: Int!
var attachment_value: String!
var best: Int!
var block_id: Int!
var build_uid: Int!
var can_delete: Int!
var can_out: Int!
var can_replay: Int!
var can_reply: Int!
var can_see_reply: Int!
var can_store: Int!
var city_id: Int!
var content: String!
var country_id: Int!
var group_id: Int!
var group_invitation_id: Int!
var group_pid: Int!
var id: Int!
var identify: Int!
var index_id: String!
var intra_id: Int!
var invitation_type: Int!
var is_empty: Int!
var labels: String!
var last_read_url: String!
var last_reply_time: String!
var last_version: Int!
var pay_perpetual_money: Int!
var pay_temporary_money: String!
var pay_type: Int!
var pid: Int!
var praise_num: Int!
var praised: Int!
var pro_id: Int!
var read_num: Int!
var remarks: String!
var replay: String!
var replay_num: Int!
var source: String!
var source_pid: Int!
var status: Int!
var store_num: Int!
var subclass: Int!
var summarize: String!
var task: String!
var title: String!
var topic_id: Int!
var topic_pid: Int!
var update_time: String!
var use_signature: Int!
var user_authority: Int!
var user_info: UserInfoData?
var vote: String!
var x_coord: Int!
var y_coord: Int!
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| swift | 2 | //
// DetailModel.swift
// UIMaster
//
// Created by hobson on 2018/7/31.
// Copyright © 2018年 one2much. All rights reserved.
//
import Foundation
// swiftlint:disable identifier_name
class DetailModel: BaseModel {
var data: DetailData?
}
class DetailData: BaseData {
var add_time: String!
var address: String!
var all_val_num: Int!
var area_id: Int!
var attachment: Int!
var attachment_download: Int!
var attachment_size: Int!
var attachment_value: String!
var best: Int!
var block_id: Int!
var build_uid: Int!
var can_delete: Int!
var can_out: Int!
var can_replay: Int!
var can_reply: Int!
var can_see_reply: Int!
var can_store: Int!
var city_id: Int!
var content: String!
var country_id: Int!
var group_id: Int!
var group_invitation_id: Int!
var group_pid: Int!
var id: Int!
var identify: Int!
var index_id: String!
var intra_id: Int!
var invitation_type: Int!
var is_empty: Int!
var labels: String!
var last_read_url: String!
var last_reply_time: String!
var last_version: Int!
var pay_perpetual_money: Int!
var pay_temporary_money: String!
var pay_type: Int!
var pid: Int!
var praise_num: Int!
var praised: Int!
var pro_id: Int!
var read_num: Int!
var remarks: String!
var replay: String!
var replay_num: Int!
var source: String!
var source_pid: Int!
var status: Int!
var store_num: Int!
var subclass: Int!
var summarize: String!
var task: String!
var title: String!
var topic_id: Int!
var topic_pid: Int!
var update_time: String!
var use_signature: Int!
var user_authority: Int!
var user_info: UserInfoData?
var vote: String!
var x_coord: Int!
var y_coord: Int!
}
|
Below is an extract from a C# program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
Add 1 point if the program contains valid C# code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
Add another point if the program addresses practical C# concepts, even if it lacks comments.
Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., LINQ, reflection). The code should be well-structured and contain some comments.
Give a fourth point if the program is self-contained and highly relevant to teaching C#. It should be similar to a school exercise, a tutorial, or a C# course section.
Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C#. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
namespace RediSearchSharp.Query
{
public class Languages
{
public const string Default = English;
public const string Arabic = "arabic";
public const string Danish = "danish";
public const string Dutch = "dutch";
public const string English = "english";
public const string Finnish = "finnish";
public const string French = "french";
public const string German = "german";
public const string Hungarian = "hungarian";
public const string Italian = "italian";
public const string Norwegian = "norwegian";
public const string Portuguese = "portuguese";
public const string Romanian = "romanian";
public const string Russian = "russian";
public const string Spanish = "spanish";
public const string Swedish = "swedish";
public const string Tamil = "tamil";
public const string Turkish = "turkish";
public const string Chinese = "chinese";
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| csharp | 1 | namespace RediSearchSharp.Query
{
public class Languages
{
public const string Default = English;
public const string Arabic = "arabic";
public const string Danish = "danish";
public const string Dutch = "dutch";
public const string English = "english";
public const string Finnish = "finnish";
public const string French = "french";
public const string German = "german";
public const string Hungarian = "hungarian";
public const string Italian = "italian";
public const string Norwegian = "norwegian";
public const string Portuguese = "portuguese";
public const string Romanian = "romanian";
public const string Russian = "russian";
public const string Spanish = "spanish";
public const string Swedish = "swedish";
public const string Tamil = "tamil";
public const string Turkish = "turkish";
public const string Chinese = "chinese";
}
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _react = require("react");
var _react2 = _interopRequireDefault(_react);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var Eye = function Eye(props) {
return _react2.default.createElement(
"svg",
_extends({ viewBox: "0 0 64 34" }, props),
_react2.default.createElement("path", {
d: "M32 .3C16 .3 0 9.8 0 17.6s16 15.8 32 15.8 32-8 32-15.8S48 .3 32 .3zm1 9.4c0-1.1.9-1.9 2-1.9s2 .9 2 1.9c0 1.1-.9 1.9-2 1.9s-2-.8-2-1.9zm-1 0c0 .8.3 1.5.8 2-.3 0-.6-.1-.8-.1-2.8 0-5 2.2-5 4.9s2.2 4.9 5 4.9 5-2.2 5-4.9c0-1.6-.8-3-2-3.9 1.7 0 3-1.3 3-2.9 0-.2 0-.4-.1-.6 2.5 1.8 4.1 4.6 4.1 7.7 0 5.3-4.5 9.6-10 9.6s-10-4.3-10-9.6 4.5-9.6 10-9.6c.4 0 .9 0 1.3.1-.8.5-1.3 1.4-1.3 2.4zM4 17.6c0-2 2.9-5.3 7.9-8.1 5.2-2.9 11.6-4.8 17.9-5.1-6.1 1-10.8 6.2-10.8 12.4 0 6.3 4.7 11.5 10.9 12.5-6.4-.3-13-1.9-18.2-4.5-5-2.5-7.7-5.4-7.7-7.2zm48.2 7.2C47 27.3 40.5 29 34 29.3c6.2-1 10.9-6.2 10.9-12.5S40.2 5.4 34.1 4.4c6.3.4 12.7 2.2 17.9 5.1 5.1 2.8 7.9 6.1 7.9 8.1.1 1.8-2.6 4.7-7.7 7.2z",
fill: "#343434"
})
);
};
exports.default = Eye;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _react = require("react");
var _react2 = _interopRequireDefault(_react);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var Eye = function Eye(props) {
return _react2.default.createElement(
"svg",
_extends({ viewBox: "0 0 64 34" }, props),
_react2.default.createElement("path", {
d: "M32 .3C16 .3 0 9.8 0 17.6s16 15.8 32 15.8 32-8 32-15.8S48 .3 32 .3zm1 9.4c0-1.1.9-1.9 2-1.9s2 .9 2 1.9c0 1.1-.9 1.9-2 1.9s-2-.8-2-1.9zm-1 0c0 .8.3 1.5.8 2-.3 0-.6-.1-.8-.1-2.8 0-5 2.2-5 4.9s2.2 4.9 5 4.9 5-2.2 5-4.9c0-1.6-.8-3-2-3.9 1.7 0 3-1.3 3-2.9 0-.2 0-.4-.1-.6 2.5 1.8 4.1 4.6 4.1 7.7 0 5.3-4.5 9.6-10 9.6s-10-4.3-10-9.6 4.5-9.6 10-9.6c.4 0 .9 0 1.3.1-.8.5-1.3 1.4-1.3 2.4zM4 17.6c0-2 2.9-5.3 7.9-8.1 5.2-2.9 11.6-4.8 17.9-5.1-6.1 1-10.8 6.2-10.8 12.4 0 6.3 4.7 11.5 10.9 12.5-6.4-.3-13-1.9-18.2-4.5-5-2.5-7.7-5.4-7.7-7.2zm48.2 7.2C47 27.3 40.5 29 34 29.3c6.2-1 10.9-6.2 10.9-12.5S40.2 5.4 34.1 4.4c6.3.4 12.7 2.2 17.9 5.1 5.1 2.8 7.9 6.1 7.9 8.1.1 1.8-2.6 4.7-7.7 7.2z",
fill: "#343434"
})
);
};
exports.default = Eye; |
Below is an extract from an HTML document. Evaluate whether it has a high educational value and could help teach web development. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document contains valid HTML markup, even if it's not educational, like boilerplate code or standard tags.
- Add another point if the document addresses practical HTML concepts and uses semantic elements appropriately.
- Award a third point if the document is suitable for educational use and introduces key web concepts, even if the topic is somewhat advanced (e.g., forms, metadata). The code should be well-structured and use clear, descriptive naming.
- Give a fourth point if the document is self-contained and highly relevant to teaching HTML. It should be similar to a school exercise, a tutorial, or an HTML course section for early learners.
- Grant a fifth point if the document is outstanding in its educational value and is perfectly suited for teaching HTML to beginners. It should be well-organized, easy to understand, and ideally include some explanatory comments or demonstrate best practices in HTML structure.
The extract:
<div class="row-fluid">
<div class="span3"></div>
<div class="span6">
<h1>Apply to Join the Community</h1>
<p>Membership fee is $2.99 per month to cover hosting and maintenance expenses.</p>
<div class="well row-fluid">
<div class="span12">
<a href="/auth/github" class="btn btn-primary btn-large">Apply with GitHub</a> (approval required)
<div><small>You need to have your real name and email set on GitHub at <a href="https://github.com/settings/profile">https://github.com/settings/profile</a>.</small>
</div>
</div>
</div>
<div class="well row-fluid">
<div class="span12">
<a href="/auth/angellist" class="btn btn-success btn-large">Apply with AngelList</a> (approval required)
</div>
</div>
<div class="well row-fluid">
<div class="span12">
<h2>Apply with Email</h2>
<form>
<label>Invite Code</label>
<input type="text" placeholder="Invite Code" name="invite"/>
<span class="help-block">To provide the best value to our community we restrict early access</span>
<label>First Name</label>
<input type="text" placeholder="Username" class="" name="firstname"/>
<label>Last Name</label>
<input type="text" placeholder="Username" class="" name="lastname"/>
<!-- <hr/> -->
<label>Email</label>
<input type="email" placeholder="Email" name="email"/>
<label>Password</label>
<input type="<PASSWORD>" placeholder="<PASSWORD>" name="<PASSWORD>"/>
<hr/>
<a class="btn btn-success btn-large" id="signup">Apply with Email</a>
</form>
</div>
</div>
</div>
<div class="span3"></div>
</div>
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| html | 2 | <div class="row-fluid">
<div class="span3"></div>
<div class="span6">
<h1>Apply to Join the Community</h1>
<p>Membership fee is $2.99 per month to cover hosting and maintenance expenses.</p>
<div class="well row-fluid">
<div class="span12">
<a href="/auth/github" class="btn btn-primary btn-large">Apply with GitHub</a> (approval required)
<div><small>You need to have your real name and email set on GitHub at <a href="https://github.com/settings/profile">https://github.com/settings/profile</a>.</small>
</div>
</div>
</div>
<div class="well row-fluid">
<div class="span12">
<a href="/auth/angellist" class="btn btn-success btn-large">Apply with AngelList</a> (approval required)
</div>
</div>
<div class="well row-fluid">
<div class="span12">
<h2>Apply with Email</h2>
<form>
<label>Invite Code</label>
<input type="text" placeholder="Invite Code" name="invite"/>
<span class="help-block">To provide the best value to our community we restrict early access</span>
<label>First Name</label>
<input type="text" placeholder="Username" class="" name="firstname"/>
<label>Last Name</label>
<input type="text" placeholder="Username" class="" name="lastname"/>
<!-- <hr/> -->
<label>Email</label>
<input type="email" placeholder="Email" name="email"/>
<label>Password</label>
<input type="<PASSWORD>" placeholder="<PASSWORD>" name="<PASSWORD>"/>
<hr/>
<a class="btn btn-success btn-large" id="signup">Apply with Email</a>
</form>
</div>
</div>
</div>
<div class="span3"></div>
</div>
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import Misty from "./lib/Misty";
// tslint:disable-next-line:no-unused-expression
new Misty();
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 1 |
import Misty from "./lib/Misty";
// tslint:disable-next-line:no-unused-expression
new Misty();
|
Below is an extract from a Ruby program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Ruby code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Ruby concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., metaprogramming, blocks). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Ruby. It should be similar to a school exercise, a tutorial, or a Ruby course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Ruby. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
json.array! @orders do |order|
json.id order.id
json.product order.product.name
json.status order.status
json.quantity order.quantity
json.unit_price order.product.price
json.total order.quantity * order.product.price
end
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| ruby | 2 | json.array! @orders do |order|
json.id order.id
json.product order.product.name
json.status order.status
json.quantity order.quantity
json.unit_price order.product.price
json.total order.quantity * order.product.price
end
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
class GenreSeeder extends Seeder
{
/**
* データベースに対するデータ設定の実行
*
* @return void
*/
public function run()
{
DB::table('genres')->insert([
[
'name' => '本',
'parent_id' => '1',
],
[
'name' => '自己啓発',
'parent_id' => '1',
],
]);
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 | <?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
class GenreSeeder extends Seeder
{
/**
* データベースに対するデータ設定の実行
*
* @return void
*/
public function run()
{
DB::table('genres')->insert([
[
'name' => '本',
'parent_id' => '1',
],
[
'name' => '自己啓発',
'parent_id' => '1',
],
]);
}
}
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
* Copyright (c) 2019 <NAME> https://gaztin.com/
*
* This software is provided 'as-is', without any express or implied warranty. In no event will
* the authors be held liable for any damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose, including commercial
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not claim that you wrote the
* original software. If you use this software in a product, an acknowledgment in the product
* documentation would be appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented as
* being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef __SWF_HEADER_H__
#define __SWF_HEADER_H__
#include <stdint.h>
#include "internal/fixed_point.h"
#include "internal/rect.h"
typedef struct
{
uint8_t signature[ 3 ];
uint8_t version;
uint32_t fileLength;
swf_rect frameSize;
swf_fixed_point_8_8 frameRate;
uint16_t frameCount;
} swf_header;
extern int swf_header__parse( struct swf_reader* rd, swf_header* outHeader );
#endif
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 2 | /*
* Copyright (c) 2019 <NAME> https://gaztin.com/
*
* This software is provided 'as-is', without any express or implied warranty. In no event will
* the authors be held liable for any damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose, including commercial
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not claim that you wrote the
* original software. If you use this software in a product, an acknowledgment in the product
* documentation would be appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented as
* being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef __SWF_HEADER_H__
#define __SWF_HEADER_H__
#include <stdint.h>
#include "internal/fixed_point.h"
#include "internal/rect.h"
typedef struct
{
uint8_t signature[ 3 ];
uint8_t version;
uint32_t fileLength;
swf_rect frameSize;
swf_fixed_point_8_8 frameRate;
uint16_t frameCount;
} swf_header;
extern int swf_header__parse( struct swf_reader* rd, swf_header* outHeader );
#endif
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';
interface FileObject {
thumbnail: string;
}
const _grid_columns_count: number = 3; // Number of columns in image grid
@Component({
selector: 'page-home',
templateUrl: 'home.html'
})
export class HomePage {
private columns: Array<number>;
private rows: Array<number>;
private fileObjects: FileObject[];
constructor(public navCtrl: NavController) {
// Create column array for number of columns you want
this.columns = new Array(_grid_columns_count);
// This array will hold the number of rows
this.rows = new Array<number>();
// This array will hold all the items in the grid.
// Add a item by appending or inserting
// Remove a item by delete your item from the array
this.fileObjects = new Array<FileObject>();
}
// Add item
addItem(obj: FileObject) {
this.fileObjects.push(obj);
// true of if condition indicates that we need a new row.
if ((this.rows.length * _grid_columns_count) < this.fileObjects.length) {
this.rows.push(this.rows.length);
}
}
// Get an item by row and column
getItemThumbnail(row: number, col: number) {
let i = row * _grid_columns_count + col;
if (i < this.fileObjects.length) {
return this.fileObjects[i].thumbnail;
}
else {
return "no found";
}
}
isValid(row: number, col: number): boolean {
let i = row * _grid_columns_count + col;
return (i < this.fileObjects.length);
}
onTapImage(row, col) {
let i = row * _grid_columns_count + col;
if (i < this.fileObjects.length) {
alert(this.fileObjects[i].thumbnail);
}
}
getTileHeight(): string {
return "100px;"
}
/*
This is a method just to simulate how we can items
change the image path as per your wish
*/
addImages() {
for (let i = 0; i < 8; ++i) {
let obj: FileObject = {
thumbnail: 'url("../assets/icon/image.jpg")'
}
th
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 2 | import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';
interface FileObject {
thumbnail: string;
}
const _grid_columns_count: number = 3; // Number of columns in image grid
@Component({
selector: 'page-home',
templateUrl: 'home.html'
})
export class HomePage {
private columns: Array<number>;
private rows: Array<number>;
private fileObjects: FileObject[];
constructor(public navCtrl: NavController) {
// Create column array for number of columns you want
this.columns = new Array(_grid_columns_count);
// This array will hold the number of rows
this.rows = new Array<number>();
// This array will hold all the items in the grid.
// Add a item by appending or inserting
// Remove a item by delete your item from the array
this.fileObjects = new Array<FileObject>();
}
// Add item
addItem(obj: FileObject) {
this.fileObjects.push(obj);
// true of if condition indicates that we need a new row.
if ((this.rows.length * _grid_columns_count) < this.fileObjects.length) {
this.rows.push(this.rows.length);
}
}
// Get an item by row and column
getItemThumbnail(row: number, col: number) {
let i = row * _grid_columns_count + col;
if (i < this.fileObjects.length) {
return this.fileObjects[i].thumbnail;
}
else {
return "no found";
}
}
isValid(row: number, col: number): boolean {
let i = row * _grid_columns_count + col;
return (i < this.fileObjects.length);
}
onTapImage(row, col) {
let i = row * _grid_columns_count + col;
if (i < this.fileObjects.length) {
alert(this.fileObjects[i].thumbnail);
}
}
getTileHeight(): string {
return "100px;"
}
/*
This is a method just to simulate how we can items
change the image path as per your wish
*/
addImages() {
for (let i = 0; i < 8; ++i) {
let obj: FileObject = {
thumbnail: 'url("../assets/icon/image.jpg")'
}
this.addItem(obj);
}
}
}
|
Below is an extract from a Kotlin program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Kotlin code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Kotlin concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., coroutines, extension functions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Kotlin. It should be similar to a school exercise, a tutorial, or a Kotlin course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Kotlin. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package kt.team.api.persist.model
import org.jetbrains.exposed.sql.Table
import org.jetbrains.exposed.sql.date
object ArticleTable : Table() {
val id = uuid("id").primaryKey().autoGenerate()
val created = date("created")
val content = text("content")
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| kotlin | 2 | package kt.team.api.persist.model
import org.jetbrains.exposed.sql.Table
import org.jetbrains.exposed.sql.date
object ArticleTable : Table() {
val id = uuid("id").primaryKey().autoGenerate()
val created = date("created")
val content = text("content")
} |
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
---
title: "Lead Like the Great Conductors"
date: 2011-01-02T00:00:00-07:00
draft: false
aliases:
- "/2011/01/02/80/index.html"
- "/2011/01/02/80/"
categories:
- entrepreneurship
- general
---
This is a beautiful exposition (and metaphor) on the role of a leader. I’ve often wondered if it’s better to set forth clear guidelines so that everyone knows exactly what to do, or better to provide people a framework within which to “tell their own story” (to use the words of Mr. Talgam in the video below).
Ultimately, I’ve found that different people respond to different styles. But if there is a “default style,” I believe the conductor who empowers the musicians to perform the music in their own style while providing subtle yet meaningful guidance on context, feeling, and intent produces the most beautiful music.
{{< vimeo 158393113>}}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 3 | ---
title: "Lead Like the Great Conductors"
date: 2011-01-02T00:00:00-07:00
draft: false
aliases:
- "/2011/01/02/80/index.html"
- "/2011/01/02/80/"
categories:
- entrepreneurship
- general
---
This is a beautiful exposition (and metaphor) on the role of a leader. I’ve often wondered if it’s better to set forth clear guidelines so that everyone knows exactly what to do, or better to provide people a framework within which to “tell their own story” (to use the words of Mr. Talgam in the video below).
Ultimately, I’ve found that different people respond to different styles. But if there is a “default style,” I believe the conductor who empowers the musicians to perform the music in their own style while providing subtle yet meaningful guidance on context, feeling, and intent produces the most beautiful music.
{{< vimeo 158393113>}} |
Below is an extract from a Kotlin program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Kotlin code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Kotlin concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., coroutines, extension functions). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Kotlin. It should be similar to a school exercise, a tutorial, or a Kotlin course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Kotlin. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package ircover.idlenation
import android.support.v4.app.Fragment
import ircover.idlenation.adapters.PageTitleModel
import ircover.idlenation.fragments.ResourceLinePageFragment
interface MainActivityPage {
fun getTitle(): CharSequence
fun createFragment(): Fragment
fun getPageTitleModel(): PageTitleModel
}
fun ResourceLine.convertToPage() = object : MainActivityPage {
var fragment: ResourceLinePageFragment? = null
override fun getTitle(): CharSequence =
"${resourceType.getTitle()}: ${resourceCount.toCommonString()}"
override fun createFragment(): ResourceLinePageFragment{
return ResourceLinePageFragment.createByType(resourceType).apply {
fragment = this
}
}
override fun getPageTitleModel(): PageTitleModel =
PageTitleModel(resourceCount, resourceType).apply {
registerOnCountUpdate { count = it }
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| kotlin | 3 | package ircover.idlenation
import android.support.v4.app.Fragment
import ircover.idlenation.adapters.PageTitleModel
import ircover.idlenation.fragments.ResourceLinePageFragment
interface MainActivityPage {
fun getTitle(): CharSequence
fun createFragment(): Fragment
fun getPageTitleModel(): PageTitleModel
}
fun ResourceLine.convertToPage() = object : MainActivityPage {
var fragment: ResourceLinePageFragment? = null
override fun getTitle(): CharSequence =
"${resourceType.getTitle()}: ${resourceCount.toCommonString()}"
override fun createFragment(): ResourceLinePageFragment{
return ResourceLinePageFragment.createByType(resourceType).apply {
fragment = this
}
}
override fun getPageTitleModel(): PageTitleModel =
PageTitleModel(resourceCount, resourceType).apply {
registerOnCountUpdate { count = it }
}
} |
Below is an extract from a shell script. Evaluate whether it has a high educational value and could help teach shell scripting. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the script contains valid shell commands, even if it's not educational, like simple system calls or basic file operations.
- Add another point if the script addresses practical shell scripting concepts (e.g., variables, conditionals), even if it lacks comments.
- Award a third point if the script is suitable for educational use and introduces key concepts in shell scripting, even if the topic is somewhat advanced (e.g., functions, process management). The script should be well-structured and contain some comments.
- Give a fourth point if the script is self-contained and highly relevant to teaching shell scripting. It should be similar to a tutorial example or a shell scripting course section, demonstrating good practices in script organization.
- Grant a fifth point if the script is outstanding in its educational value and is perfectly suited for teaching shell scripting. It should be well-written, easy to understand, and contain step-by-step explanations in comments.
The extract:
COMPOSE_PROJECT_NAME=my_project
APP_SOURCE_PATH=../app_src
TZ=Asia/Tokyo
HOST_HTTP_PORT=10080
HOST_PHP_PORT=19000
HOST_DB_PORT=15432
HOST_MAILHOG_PORT=18025
HTTP_PORT=80
PHP_PORT=9000
POSTGRES_USER=postgres
POSTGRES_PASSWORD=<PASSWORD>
MAILHOG_PORT=8025
# Laravel Environment Variables
DB_CONNECTION=pgsql
DB_HOST=postgres
DB_PORT=5432
DB_DATABASE=my_project_db
DB_USERNAME=my_project_db_user
DB_PASSWORD=<PASSWORD>
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=<EMAIL>
MAIL_PASSWORD=<PASSWORD>
MAIL_FROM_ADDRESS=<EMAIL>
APP_URL=http://localhost
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| shell | 2 | COMPOSE_PROJECT_NAME=my_project
APP_SOURCE_PATH=../app_src
TZ=Asia/Tokyo
HOST_HTTP_PORT=10080
HOST_PHP_PORT=19000
HOST_DB_PORT=15432
HOST_MAILHOG_PORT=18025
HTTP_PORT=80
PHP_PORT=9000
POSTGRES_USER=postgres
POSTGRES_PASSWORD=<PASSWORD>
MAILHOG_PORT=8025
# Laravel Environment Variables
DB_CONNECTION=pgsql
DB_HOST=postgres
DB_PORT=5432
DB_DATABASE=my_project_db
DB_USERNAME=my_project_db_user
DB_PASSWORD=<PASSWORD>
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=<EMAIL>
MAIL_PASSWORD=<PASSWORD>
MAIL_FROM_ADDRESS=<EMAIL>
APP_URL=http://localhost
|
Below is an extract from a Ruby program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Ruby code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Ruby concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., metaprogramming, blocks). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Ruby. It should be similar to a school exercise, a tutorial, or a Ruby course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Ruby. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
module Stepable
def moves
moves = []
move_diffs.each do |diff|
dx, dy = diff
test_pos = [self.pos[0] + dx, self.pos[1] + dy]
moves << test_pos if @rows[test_pos].empty? && covered?(test_pos)
end
moves
end
private
def move_diffs
self.move_diffs
end
def covered?(pos)
(0..7).cover?(pos[0]) && (0..7).cover?(pos[1])
end
end
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| ruby | -1 | module Stepable
def moves
moves = []
move_diffs.each do |diff|
dx, dy = diff
test_pos = [self.pos[0] + dx, self.pos[1] + dy]
moves << test_pos if @rows[test_pos].empty? && covered?(test_pos)
end
moves
end
private
def move_diffs
self.move_diffs
end
def covered?(pos)
(0..7).cover?(pos[0]) && (0..7).cover?(pos[1])
end
end |
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package signal
import (
"github.com/aseTo2016/app-footstone/pkg/runtime"
"log"
"os"
"os/signal"
"syscall"
)
var receiver = make(chan os.Signal)
func init() {
signal.Notify(receiver, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
}
func Listen() {
go func() {
select {
case data := <-receiver:
log.Printf("%v", data)
log.Println(runtime.Stack())
}
}()
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 3 | package signal
import (
"github.com/aseTo2016/app-footstone/pkg/runtime"
"log"
"os"
"os/signal"
"syscall"
)
var receiver = make(chan os.Signal)
func init() {
signal.Notify(receiver, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
}
func Listen() {
go func() {
select {
case data := <-receiver:
log.Printf("%v", data)
log.Println(runtime.Stack())
}
}()
}
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
$ip="127.0.0.1";
$pocket="2001";
$serverce=socket_create(AF_INET,SOCK_STREAM,SOL_TCP);
if($serverce==false)
{
echo "服务器创建socket失败！";
exit(0);
}
$p=socket_bind($serverce,$ip,$pocket);
if($p==false)
{
echo "绑定失败";
exit(0);
}
$p=socket_listen($serverce,5);
if($p==false)
{
echo "监听失败！";
exit(0);
}
$p=socket_set_block($serverce);
if($p==false)
{
echo "监听失败！";
exit(0);
}
$date=0;
while(true)
{
$client=socket_accept($serverce);
$date++;
socket_write($client,"你是第".$date."个发过信息来的人!");
$msg=socket_read($client,1024);
echo "已经收到第".$date."个客户端的信息!";
echo "\r\n";
echo "收到的信息是".$msg;
if($date=="10")
{
echo "将要关闭server_socket";
echo "-----------------".($date=="10")."----------------------";
//echo "date is :".$date;
break;
}
}
echo "date is :".$date;
echo "满了10个了，可以关闭服务器了啊!";
socket_close($serverce);
?>
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 3 | <?php
$ip="127.0.0.1";
$pocket="2001";
$serverce=socket_create(AF_INET,SOCK_STREAM,SOL_TCP);
if($serverce==false)
{
echo "服务器创建socket失败！";
exit(0);
}
$p=socket_bind($serverce,$ip,$pocket);
if($p==false)
{
echo "绑定失败";
exit(0);
}
$p=socket_listen($serverce,5);
if($p==false)
{
echo "监听失败！";
exit(0);
}
$p=socket_set_block($serverce);
if($p==false)
{
echo "监听失败！";
exit(0);
}
$date=0;
while(true)
{
$client=socket_accept($serverce);
$date++;
socket_write($client,"你是第".$date."个发过信息来的人!");
$msg=socket_read($client,1024);
echo "已经收到第".$date."个客户端的信息!";
echo "\r\n";
echo "收到的信息是".$msg;
if($date=="10")
{
echo "将要关闭server_socket";
echo "-----------------".($date=="10")."----------------------";
//echo "date is :".$date;
break;
}
}
echo "date is :".$date;
echo "满了10个了，可以关闭服务器了啊!";
socket_close($serverce);
?> |
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use wasm_bindgen::prelude::*;
use wasm_bindgen_test::*;
use web_sys::HtmlHeadingElement;
#[wasm_bindgen(module = "/tests/wasm/element.js")]
extern "C" {
fn new_heading() -> HtmlHeadingElement;
}
#[wasm_bindgen_test]
fn heading_element() {
let element = new_heading();
assert_eq!(element.align(), "", "Shouldn't have an align");
element.set_align("justify");
assert_eq!(element.align(), "justify", "Should have an align");
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 3 | use wasm_bindgen::prelude::*;
use wasm_bindgen_test::*;
use web_sys::HtmlHeadingElement;
#[wasm_bindgen(module = "/tests/wasm/element.js")]
extern "C" {
fn new_heading() -> HtmlHeadingElement;
}
#[wasm_bindgen_test]
fn heading_element() {
let element = new_heading();
assert_eq!(element.align(), "", "Shouldn't have an align");
element.set_align("justify");
assert_eq!(element.align(), "justify", "Should have an align");
}
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use std::collections::HashMap;
#[path = "data.rs"]
mod data;
#[path = "base.rs"]
mod base;
static REMOTE_REFS_BASE: &'static str = "refs/heads/";
static LOCAL_REFS_BASE: &'static str = "refs/remote/";
pub fn fetch(path: String) {
// Get refs from server
let refs = get_remote_refs(path.clone(), REMOTE_REFS_BASE);
let commit_oids: Vec<&String> = refs.values().collect();
base::copy_objects_in_commits_and_parents(commit_oids, path.clone(), false);
// Update local refs to match server
for (remote_name, value) in refs.iter() {
let refname = remote_name.trim_start_matches(REMOTE_REFS_BASE);
data::update_ref(
format!("{}/{}", LOCAL_REFS_BASE, refname),
data::RefValue {
symbolic: false,
value: value.clone(),
},
true,
)
}
}
pub fn push(remote_path: String, reference: String) {
let refs = get_remote_refs(remote_path.clone(), REMOTE_REFS_BASE);
let empty = "".to_owned();
let remote_ref = refs.get(&reference).unwrap_or(&empty);
let local_ref = data::get_ref(reference.clone(), true).value;
assert!(local_ref != "".to_string());
// Don't allow force push
assert!(
*remote_ref == "".to_owned() || base::is_ancestor_of(local_ref.clone(), remote_ref.clone())
);
let commit_oids = vec![&local_ref];
base::copy_objects_in_commits_and_parents(commit_oids, remote_path.clone(), true);
data::set_rgit_dir(remote_path.as_str());
data::update_ref(
reference,
data::RefValue {
symbolic: false,
value: local_ref,
},
true,
);
data::reset_rgit_dir();
}
fn get_remote_refs(path: String, prefix: &str) -> HashMap<String, String> {
let mut refs = HashMap::new();
data::set_rgit_dir(path.as_str());
for (refname, reference) in data::iter_refs(prefix, true) {
refs.insert(refname, reference.value);
}
data::reset_rgit_dir();
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | -1 | use std::collections::HashMap;
#[path = "data.rs"]
mod data;
#[path = "base.rs"]
mod base;
static REMOTE_REFS_BASE: &'static str = "refs/heads/";
static LOCAL_REFS_BASE: &'static str = "refs/remote/";
pub fn fetch(path: String) {
// Get refs from server
let refs = get_remote_refs(path.clone(), REMOTE_REFS_BASE);
let commit_oids: Vec<&String> = refs.values().collect();
base::copy_objects_in_commits_and_parents(commit_oids, path.clone(), false);
// Update local refs to match server
for (remote_name, value) in refs.iter() {
let refname = remote_name.trim_start_matches(REMOTE_REFS_BASE);
data::update_ref(
format!("{}/{}", LOCAL_REFS_BASE, refname),
data::RefValue {
symbolic: false,
value: value.clone(),
},
true,
)
}
}
pub fn push(remote_path: String, reference: String) {
let refs = get_remote_refs(remote_path.clone(), REMOTE_REFS_BASE);
let empty = "".to_owned();
let remote_ref = refs.get(&reference).unwrap_or(&empty);
let local_ref = data::get_ref(reference.clone(), true).value;
assert!(local_ref != "".to_string());
// Don't allow force push
assert!(
*remote_ref == "".to_owned() || base::is_ancestor_of(local_ref.clone(), remote_ref.clone())
);
let commit_oids = vec![&local_ref];
base::copy_objects_in_commits_and_parents(commit_oids, remote_path.clone(), true);
data::set_rgit_dir(remote_path.as_str());
data::update_ref(
reference,
data::RefValue {
symbolic: false,
value: local_ref,
},
true,
);
data::reset_rgit_dir();
}
fn get_remote_refs(path: String, prefix: &str) -> HashMap<String, String> {
let mut refs = HashMap::new();
data::set_rgit_dir(path.as_str());
for (refname, reference) in data::iter_refs(prefix, true) {
refs.insert(refname, reference.value);
}
data::reset_rgit_dir();
return refs;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.