text:
# DISCONTINUATION OF PROJECT #
This project will no longer be maintained by Intel.
Intel has ceased development and contributions including, but not limited to, maintenance, bug fixes, new releases, or updates, to this project.
Intel no longer accepts patches to this project.
# Store Traffic Monitor

| Details               |                    |
| --------------------- | ------------------ |
| Target OS:            | Ubuntu\* 18.04 LTS |
| Programming Language: | C++                |
| Time to Complete:     | 50-70min           |

![store-traffic-monitor](docs/images/store-traffic-monitor-image.png)

## What It Does

The store traffic monitor reference implementation gives the total number of people currently present and total number of people visited the facility. It also counts the product inventory. The application is capable of processing the inputs from multiple cameras and video files.

## Requirements

### Hardware

- 6th to 8th Generation Intel® Core™ processors with Iris® Pro graphics or Intel® HD Graphics

### Software

- [Ubuntu\* 18.04 LTS](http://releases.ubuntu.com/18.04/)

  **Note**: We recommend using a 4.14+ Linux* kernel with this software. Run the following command to determine the kernel version:

     ```
     uname -a
     ```

- OpenCL™ Runtime Package

- Intel® Distribution of OpenVINO™ toolkit 2020 R3 Release

## How It Works

The application uses the Inference Engine included in the Intel® Distribution of OpenVINO™ toolkit. A trained neural network detects objects by displaying a green bounding box over them. This reference implementation identifies multiple objects entering the frame and records the class of each object, the count, and the time the object entered the frame.
![Architectural Diagram](docs/images/arch.png)

**Figure 2:** Architectural Diagram.

## Setup
### Get the code
Clone the reference implementation
```
sudo apt-get update && sudo apt-get install git
git clone https://github.com/intel-iot-devkit/store-traffic-monitor-cpp.git
```

### Install OpenVINO

Refer to [Install Intel® Distribution of OpenVINO™ toolkit for Linux*](https://software.intel.com/en-us/articles/OpenVINO-Install-Linux) to learn how to install and configure the toolkit.

Install the OpenCL™ Runtime Package to run inference on the GPU, as shown in the instructions below. It is not mandatory for CPU inference.

### Other Dependencies
**FFmpeg***

FFmpeg is a free and open-source project capable of recording, converting and streaming digital audio and video in various formats. It can be used to do most of our multimedia tasks quickly and easily say, audio compression, audio/video format conversion, extract images from a video and a lot more.

### Which Model to Use

This application uses the [mobilenet-ssd](https://github.com/chuanqi305/MobileNet-SSD) model, that can be accessed using the **model downloader**. The **model downloader** downloads the model as Caffe* model files. These need to be passed through the **model optimizer** to generate the IR (the __.xml__ and __.bin__ files) that will be used by the application.

The application also works with any object-detection model, provided it has the same input and output format of the SSD model.
The model can be any object detection model:
- Downloaded using the **model downloader**, provided by Intel® Distribution of OpenVINO™ toolkit.

- Built by the user.

To download the models and install the dependencies of the application, run the below command in the `store-traffic-monitor-cpp` directory:
```
./setup.sh
```

### The Labels File

The application requires a _labels_ file associated with the model used for detection.

 All detection models work with integer labels, not string labels (e.g., For the ssd300 and mobilenet-ssd models, the number 15 represents the class "person".). Each model must have a _labels_ file, which associates an integer, the label the algorithm detects, with a string denoting the human-readable label.

The _labels_ file is a text file containing all the classes/labels that the model can recognize, in the order that it was trained to recognize them, one class per line.

For mobilenet-ssd model, _labels.txt_ file is provided in the _resources_ directory.

### The Config File

The _resources/config.json_ contains the path of videos and label that will be used by the application as input. Each block represents one video file and its corresponding label for detection.

For example:
   ```
   {
       "inputs": [
          {
              "video":"path_to_video/video1.mp4",
              "label":"person"
          }
       ]
   }
   ```

The `path/to/video` is the path to an input video file and the `label` of the class (e.g., person, bottle) to be detected on that video. The labels used in the _config.json_ file must coincide with the labels from the _labels_ file.

The application can use any number of videos for detection (i.e., the _config.json_ file can have any number of blocks), but the more videos the application uses in parallel, the more the frame rate of each video scales down. This can be solved by adding more computation power to the machine on which the application is running.

### Which Input Video to use

The application works with any input video. Sample videos are provided [here](https://github.com/intel-iot-devkit/sample-videos/).

For first-use, we recommend using the [people-detection](https://github.com/intel-iot-devkit/sample-videos/blob/master/people-detection.mp4), [one-by-one-person-detection](https://github.com/intel-iot-devkit/sample-videos/blob/master/one-by-one-person-detection.mp4), [bottle-detection](https://github.com/intel-iot-devkit/sample-videos/blob/master/bottle-detection.mp4) videos.
For example:

```
{
   "inputs":[
      {
         "video":"sample-videos/people-detection.mp4",
         "label":"person"
      },
      {
         "video":"sample-videos/one-by-one-person-detection.mp4",
         "label":"person"
      },
      {
         "video":"sample-videos/bottle-detection.mp4",
         "label":"bottle"
      }
   ]
}
```

If the user wants to use any other video, it can be used by providing the path in the config.json file.

### Using the Camera Stream instead of video

Replace `path/to/video` with the camera ID in the config.json file, where the ID is taken from the video device (the number X in /dev/videoX).

On Ubuntu, to list all available video devices use the following command:

```
ls /dev/video*
```

For example, if the output of above command is __/dev/video0__, then config.json would be:

```
  {
     "inputs": [
        {
           "video":"0",
           "label":"person"
        }
     ]
   }
```

### Setup the Environment

Configure the environment to use the Intel® Distribution of OpenVINO™ toolkit by exporting environment variables:

```
source /opt/intel/openvino/bin/setupvars.sh
```

__Note__: This command needs to be executed only once in the terminal where the application will be executed. If the terminal is closed, the command needs to be executed again.

### Build the Application

To build, go to the `store-traffic-monitor-cpp` and run the following commands:

```
mkdir -p build && cd build
cmake -DUI_OUTPUT=OFF ..
make
```

## Run the Application

To see a list of the various options:

```
./store-traffic-monitor -h
```

A user can specify what target device to run on by using the device command-line argument `-d` followed by one of the devices _CPU_, _GPU_, _HDDL_ or _MYRIAD_. If no target device is specified the application will run on the CPU by default.
To run with multiple devices use _-d MULTI:device1,device2_. For example: _-d MULTI:CPU,GPU,MYRIAD_

### Run on the CPU

Although the application runs on the CPU by default, this can also be explicitly specified through the `-d CPU` command-line argument:

```
./store-traffic-monitor -d CPU -m ../resources/FP32/mobilenet-ssd.xml -l ../resources/labels.txt
```
**Note:** By default, the application runs on async mode. To run the application on sync mode, use `-f sync` as command-line argument.

### Run on the Integrated GPU
- To run on the integrated Intel® GPU with floating point precision 32 (FP32), use the `-d GPU` command-line argument:

    ```
    ./store-traffic-monitor -d GPU -m ../resources/FP32/mobilenet-ssd.xml -l ../resources/labels.txt
    ```
    **FP32**: FP32 is single-precision floating-point arithmetic uses 32 bits to represent numbers. 8 bits for the magnitude and 23 bits for the precision. For more information, [click here](https://en.wikipedia.org/wiki/Single-precision_floating-point_format)

- To run on the integrated Intel® GPU with floating point precision 16 (FP16), use the following command:
    ```
    ./store-traffic-monitor -d GPU -m ../resources/FP16/mobilenet-ssd.xml -l ../resources/labels.txt
    ```
    **FP16**: FP16 is half-precision floating-point arithmetic uses 16 bits. 5 bits for the magnitude and 10 bits for the precision. For more information, [click here](https://en.wikipedia.org/wiki/Half-precision_floating-point_format)

### Run on the Intel® Neural Compute Stick

To run on the Intel® Neural Compute Stick, use the `-d MYRIAD` command-line argument.

```
./store-traffic-monitor -d MYRIAD -m ../resources/FP16/mobilenet-ssd.xml -l ../resources/labels.txt
```

**Note:** The Intel® Neural Compute Stick can only run FP16 models. The model that is passed to the application, through the `-m <path_to_model>` command-line argument, must be of data type FP16.

### Run on the Intel® Movidius™ VPU
To run on the Intel® Movidius™ VPU, use the `-d HDDL ` command-line argument:

```
./store-traffic-monitor -d HDDL -m ../resources/FP16/mobilenet-ssd.xml -l ../resources/labels.txt
```
**Note:** The HDDL-R can only run FP16 models. The model that is passed to the application, through the `-m <path_to_model>` command-line argument, must be of data type FP16.

### Loop the Input Video

By default, the application reads the input videos only once and ends when the videos end.

The reference implementation provides an option to loop the video so that the input videos and application run continuously.

To loop the sample video, run the application with the `-lp true` command-line argument:

```
./store-traffic-monitor -lp true -d CPU -m ../resources/FP32/mobilenet-ssd.xml -l ../resources/labels.txt
```

This looping does not affect live camera streams, as camera video streams are continuous and do not end.

## Use the Browser UI

The default application uses a simple user interface created with OpenCV. A web based UI with more features is also provided with this application.

For the application to work with the browser UI, the output format must be slightly changed. This is done by compiling the application with `UI_OUTPUT` variable set:

```
cmake -DUI_OUTPUT=ON ..
make
```

Follow the readme provided [here](./UI) to run the web based UI.


text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "A Utility-aware Visual Approach for Anonymizing Multi-attribute Tabular Data."
authors: [
    Xumeng Wang,
    Jia-Kai Chou,
    Wei Chen,
    Huihua Guan,
    Wenlong Chen,
    Tianyi Lao
    Kwan-Liu Ma
  ]
date: 2017-08-29T15:46:02+08:00
doi: ""

# Publication type.
# Legend: 0 = Uncategorized; 1 = Conference paper; 2 = Journal article;
# 3 = Preprint / Working Paper; 4 = Report; 5 = Book; 6 = Book section;
# 7 = Thesis; 8 = Patent
publication_types: ["2"]

# Publication name and optional abbreviated publication name.
publication: "IEEE Transactions on Visualization and Computer Graphics"
publication_short: "IEEE TVCG"

abstract: "Sharing data for public usage requires sanitization to prevent sensitive information from leaking. Previous studies have presented methods for creating privacy preserving visualizations. However, few of them provide sufcient feedback to users on how much utility is reduced (or preserved) during such a process. To address this, we design a visual interface along with a data manipulation pipeline that allows users to gauge utility loss while interactively and iteratively handling privacy issues in their data. Widely known and discussed types of privacy models, i.e., syntactic anonymity and differential privacy, are integrated and compared under different use case scenarios. Case study results on a variety of examples demonstrate the effectiveness of our approach."

# Summary. An optional shortened abstract.
summary: ""

tags:
  [
    "Privacy Preservating Visualization",
    "Utility Aware Anonymization",
    "Syntactic Anonymity",
    "Differential Privacy",
  ]
categories: []
featured: false

# Custom links (optional).
#   Uncomment and edit lines below to show custom links.
# links:
# - name: Follow
#   url: https://twitter.com
#   icon_pack: fab
#   icon: twitter

url_pdf:
  - http://www.cad.zju.edu.cn/home/vagblog/VAG_Work/2017privacy.pdf
url_code:
url_dataset:
url_poster:
url_project:
url_slides:
url_source:
url_video:
  - https://vimeo.com/230830747
  - https://vimeo.com/238503046

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: "featured"
  focal_point: "Top"
  preview_only: false

# Associated Projects (optional).
#   Associate this publication with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `internal-project` references `content/project/internal-project/index.md`.
#   Otherwise, set `projects: []`.
projects: []

# Slides (optional).
#   Associate this publication with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides: "example"` references `content/slides/example/index.md`.
#   Otherwise, set `slides: ""`.
slides: ""
---

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Basic operations on system models

* **[`inv`](@ref)**  Inversion of a system.
* **[`ldiv`](@ref)**   Left division for two systems (also overloaded with **`\`**).
* **[`rdiv`](@ref)**   Right division for two systems (also overloaded with **`/`**).
* **[`gdual`](@ref)**   Building the dual of a descriptor system (also overloaded with **`transpose`**)
* **[`ctranspose`](@ref)**  Building the conjugate transpose of a system (also overloaded with **`adjoint`** and **`'`**).
* **[`adjoint`](@ref)**  Building the adjoint of a system.

```@docs
DescriptorSystems.inv
ldiv
rdiv
gdual
ctranspose
DescriptorSystems.adjoint
```

branch_name: refs/heads/main

gha_language: Julia

gha_license_id: MIT


text:
# Modules

Modules are simply an addition to the [Cascading Filesystem](files).  A module can add any kind of file (controllers, views, classes, config files, etc.) to the filesystem available to Koseven (via [KO7::find_file]).  This is useful to make any part of your application more transportable or shareable between different apps.  For example, creating a new modeling system, a search engine, a css/js manager, etc.

## Where to find modules

You can find them on our [Website](https://koseven.dev/modules.html) or our [GithHub](https://github.com/koseven/koseven.dev/blob/master/modules.md)

## Enabling modules

Modules are enabled by calling [KO7::modules] and passing an array of `'name' => 'path'`.  The name isn't important, but the path obviously is.  A module's path does not have to be in `MODPATH`, but usually is.  You can only call [KO7::modules] once.

	Kohana::modules(array(
		'auth'       => MODPATH.'auth',       // Basic authentication
		'cache'      => MODPATH.'cache',      // Caching with multiple backends
		'codebench'  => MODPATH.'codebench',  // Benchmarking tool
		'database'   => MODPATH.'database',   // Database access
		'image'      => MODPATH.'image',      // Image manipulation
		'orm'        => MODPATH.'orm',        // Object Relationship Mapping
		'oauth'      => MODPATH.'oauth',      // OAuth authentication
		'pagination' => MODPATH.'pagination', // Paging of results
		'unittest'   => MODPATH.'unittest',   // Unit testing
		'userguide'  => MODPATH.'userguide',  // User guide and API documentation
		));

## Init.php

When a module is activated, if an `init.php` file exists in that module's directory, it is included.  This is the ideal place to have a module include routes or other initialization necessary for the module to function.  The Userguide and Codebench modules have init.php files you can look at.

## How modules work

A file in an enabled module is virtually the same as having that exact file in the same place in the application folder.  The main difference being that it can be overwritten by a file of the same name in a higher location (a module enabled after it, or the application folder) via the [Cascading Filesystem](files).  It also provides an easy way to organize and share your code.

## Creating your own module

To create a module simply create a folder (usually in `DOCROOT/modules`) and place the files you want to be in the module there, and activate that module in your bootstrap.  To share your module, you can upload it to [Github](http://github.com).  You can look at examples of modules made by [Koseven](https://github.com/koseven/koseven/tree/master/modules) or [other users](#where-to-find-modules).

repository: uBizzy/koseven

branch_name: refs/heads/devel

gha_language: PHP

gha_license_id: NOASSERTION

repo_name: uBizzy/koseven


text:
# usePicasso

Renders a [picasso.js](https://github.com/qlik-oss/picasso.js) visualization to an html element.
If any of the input parameters are changed/updated (typically the `layout`), the rendered chart will be updated.
For picasso.js docs, head over to [picassojs.com](https://picassojs.com/).

In addition to React 16.8.1 or later, [picasso.js](https://www.npmjs.com/package/picasso.js) and [picasso-plugin-q](https://www.npmjs.com/package/picasso-plugin-q) must be installed to use this hook.

The q plugin must be registered on the picasso global scope, in order for picasso to understand the QIX hypercube.
```
picasso.use(picassoQ);
```

## Usage

```jsx
import { useRef } from 'react';
import { usePicasso } from 'hamus.js';
import picasso from 'picasso.js';
import picassoQ from 'picasso-plugin-q';

picasso.use(picassoQ);

const Demo = (settings, layout) => {
  const element = useRef(null);
  const layout = usePicasso(element, settings, layout);

  return (
    <div className="chart-div" ref={element} />
  );
};
```

## Reference
- The `element` is the html element where the chart will be rendered.
- `settings`  is the picasso.js settings object ([docs](https://picassojs.com/docs/chart.html)) which contains info about the chart (components, scales etc).
- `layout` is the object containing the hypercube data which will be shown in the chart.

gha_language: JavaScript


text:
# Global Indicator Project - proposed indicator discussion

Our methodology is to use globally open spatial data (especially OSM) first and foremost, and write process modules and python scripts to generate indicator calculation results. Then validate/supplement/substitute local (mostly open government) data if available and needed.  In analysing our results, we will need to comment (or even better, systematically benchmark) on a city-by-city basis the extent to which coverage/completeness of the data may have influenced the results for that city.

Questions remain:
** Define study region: administrative boundaries vs. city built-up area; urban vs. rural (justify OSM usage by restricting to urban).
	- Define urban centers: [the Global Human settlements project](https://ghsl.jrc.ec.europa.eu/ucdb2018visual.php)
** [Population Grids and Hexbin approaches](https://3.basecamp.com/3662734/buckets/11779922/messages/1857993142)
	- Potential population data source: [the Global Human settlements project](https://ghsl.jrc.ec.europa.eu/ucdb2018visual.php) (population by 1km grid squares)
** [Sample point selection](https://3.basecamp.com/3662734/buckets/11779922/messages/1770544113)
** [Frequent public transport definition](https://3.basecamp.com/3662734/buckets/11779922/messages/1825449219)
** Open space [source](https://3.basecamp.com/3662734/buckets/11779922/messages/1797801069) and [definition](https://3.basecamp.com/3662734/buckets/11779922/messages/1857459723)

## 1. Walkability (z-scores for local neigborhood dwelling density, street connectivity and daily living score)

### street connectivity (calculated via OSMnx load stats, clean intersection density)
- cleaned intersection density for each local walkable neighborhood (the number of cleaned intersections of pedestrain network/total local walkable area)

### dwelling density
- gross density: total number of dwellings within the cities/total area
- net density: use population raster (eg worldpop, or other) to derive a scaled-population density measure to serve as a proxy measure for dwelling density (e.g. take sum of population cells intersecting sausage buffer and divide by some indicative number for population per dwelling (e.g. 4) then standardise that result by dividing by the area of the sausage buffer in Hectares

### land use mix/daily living scores
- % of land use allocated to residential, retail, civic and institutional, entertainment, recreation, food-related (can we get the land use data?)
- access to POIs (e.g. convenience, supermarket, and public transport stop)
	- using the sausage buffer technique and binary measures =1 for at least one POI within the walkable neighborhood, =0 for no POI within the walkable neighborhood. Counting the percentage of resident address/sample points within 1km/15min walk of an POI.
	- using the [pandana approach](https://github.com/gboeing/urban-data-science/blob/59afcff905649c5f8d1f8256ec37f28496e0c740/20-Accessibility-Walkability/pandana-accessibility-demo-full.ipynb) for network accessibility and walkability analysis: calculate distance to the nearest pois for each sample point neighborhood. Calculate the accessibility score based on the presence of at least one pois within 1km/15min walk using OD analysis for distance to the closest. (Or evaluate access with a destination specific soft threshold. [this post](https://3.basecamp.com/3662734/buckets/11779922/messages/1813713976))

** local walkable neighborhood: a 1600m walkable network and 50m buffer around OSM pedestrain street
** Buffering technique referring to Forsyth et al [here](https://ij-healthgeographics.biomedcentral.com/articles/10.1186/1476-072X-11-14). Mavoa et al 2018, see [here](https://www.jtlu.org/index.php/jtlu/article/view/1132)
** Referring to ['walk and the city'](http://geochoros.survey.ntua.gr/walkandthecity/methodology) project:
	- evaluate local street connectivity for sample points
	- evaluate a land use mix or proxy score (e.g. 'daily living' access to amenities) for sample points
	- take average of these to 250m grid.
	- Then we have population density (pop/area in hectares of 250m grid cell), street connectivity (average connectivity per square km of local road networks in grid cell), and daily living access (average score from 0 to 3 for access to daily living amenities in grid cell)
	- Calculate respective z-scores of pop (or dwelling) density, street connectivity and daily living
	- Sum z-scores for a walkability index calculated for 250m grid cells

## 2. Transport
### Access to any public transport
- % of population within mode specific distance to any public transport
- % of population to any frequent public transport within mode specific distance (how to define frequent transport - serviced every ? minutes on a normal day)

### Road and pedestrian network ratio
- Full road network (km) to pedestrian network (km)

## 3. Employment
### Access to employment
- % of population within 30 mins of home by walking
- % of population within 30 mins of home by cycling
- % of population within 30 mins of home by public transport

### Employment ratio
- Employed persons to working population

### Commute Distance
- Median commute distance for area

## 4. Density
### Access to places
- % of population within 1.2km of activity centres
- % of population within 1.2km of public transport hubs
- % of population within 1.2km of urban fringe developments

- % of urban fringe population within 1.2km of activity centres and public transport hubs
- % of non-urban fringe population within 1.2km of activity centres and public transport hubs

## 5. Destinations

## 6. Open space
- % of land area allocated to open space
- % of population access to public open space


text:
# Arduino Sketches

This directory contains sketches created with the Arduino libraries.
Arduino code is usually tainted by GPL, so this code is kept separate.

## Sketches

- lights-sensor (the re:publica 2015 sensor code, updated)
- lights-lamp (the re:publica 2015 lamp code, updated)

repository: ubirch/ubirch-lights

repo_name: ubirch/ubirch-lights


text:
# Alternative Output Options

This folder contains alternative output processors you can use for your alarm.
For obvious reasons we do not support all the output options available, but you
can easily build your own.

## How to use an alternative output option

Alternative output options or Output Processors come in pair of files with the
same name, one with extension .cpp and the other one with extension .h.
To use an alternative output processor you have to first copy the two files to
the project root directory. After that edit the project main file
ArduinoOpenAlarm.ino and change the lines:

```
#include "USBOutputProcessor.h"
USBOutputProcessor outP;
```

...to match the processor you want to use. For example for the LCD Output
Processor the lines should be:

```
#include "LCDOutputProcessor.h"
LCDOutputProcessor outP;
```

Apart from that, most alternative output processors have custom configurations
you can (sometimes have to) change, like PIN numbers, communication addresses,
etc. Always take a quick look at the .h file. They usually have enough in-line
information for configuration variables.

## Options available

- LCDOutputProcessor: Output option for LCD displays of the type of those with
1, 2 or 4 lines, with 8-40 characters in their I2C and non I2C versions.

repository: msoffredi/ArduinoOpenAlarm

repo_name: msoffredi/ArduinoOpenAlarm


text:
# Drive Helper
> This project is open source on [Github](https://www.github.com/theRookieCoder/drive_helper)
> Made by [theRookieCoder](https://www.github.com/theRookieCoder)

Drive Helper is an easy to use library for interfacing with Google Drive and Google sign in.
Drive Helper is better than using `google_sign_in` and `googleapis` because it is much more intuitive for you as a developer to use and integrate into a project. If you already use Drive API, then you probably wrote a wrapper class anyways for initialisation and read/write so why not use Drive Helper as a (maybe) drop in replacement?

## Get started

Follow the instruction in the [get started guide](https://github.com/theRookieCoder/drive_helper/blob/main/doc/DriveHelper.md) to start using Drive Helper in your Flutter project, or migrate to it for an existing app using Drive API

## Features

- Signs in to Google and maintains the account seperately from your app
- Exposed DriveAPI, GoogleSignIn & GoogleSignInAccount to help with possibly missing functionality
- 2 methods for reading, 2 for writing, one for creating files, and one for deleting them
- Predefined mime types for use in creating and exporting files
- Predefined scopes for easily selecting one to create your Google account with
- Getters for the account's name, email address, and avatar

## Examples

For examples, see the [example app](example/lib/main.dart). There are simply too many methods and variables to show one example for. However the code below does show how to initialise the library

To see a commercial app that uses this library, see the app that inspired this libray [BP Logger](https://www.github.com/theRookieCoder/bp_logger)

```dart
class MyApp extends StatelessWidget {
  DriveHelper driveHelper = DriveHelper();

  Widget build() {
    return MaterialApp(
      // Theming etc, etc
      body: FutureBuilder(
        future: driveHelper.signInAndInit(DriveScopes.app),
        builder: (snapshot, context) {
          if (snapshot.connectionState == ConnectionState.done &&
            !snapshot.hasError) {
            return HomePage(driveHelper: driveHelper);
          } else if (snapshot.connectionState == ConnectionState.done &&
            snapshot.hasError) {
            return ErrorPage(error: snapshot.error);
          } else {
            return Container(
              width: MediaQuery.of(context).size.width / 1.5,
              height: MediaQuery.of(context).size.width / 1.5,
              child: CircularProgrssIndicator(strokeWidth: 10),
            );
          }
        }
      ),
    );
  }
}
```

## API Reference
See the [generated Dartdocs](https://pub.dev/documentation/drive_helper/latest/) in pub for thorough API reference

## Compatibility

This library of sorts is actually just a wrapper around [Google sign in](https://pub.dev/packages/google_sign_in) and [Google APIs](https://pub.dev/packages/googleapis) and so the contraints of those packages are inherited by this library


text:
# wipro-digital

Please build a single page displaying the 5 day weather forecast for a location of your choice, using the data from <http://openweathermap.org/forecast5>. Use HTML5/CSS3/JavaScript to implement this. You are also free to use whatever frameworks and such that you like as well as any package and build managers and testing frameworks that you are familiar with.

You should:

* Use the API to retrieve the current 5 day weather forecast in JSON and render it on the page.
* Give some thought to what will make for a decent user experience, but with no need to go all out on sleek and flashy UI elements.
* Ensure your code works on the following browsers (only needs to support the last two major versions for each browser):
  - [x] Safari
  - [x] Chrome
  - [x] Firefox
  - [x] Internet Explorer
* Produce a responsive page
* Please ensure that what you do implement is good quality code using engineering best practices and runs without any bugs, crashes or issues.
* Be prepared to discuss any tradeoffs you make.

Please upload your code to GitHub. Please make sure the GitHub project is public and respond back to us with the URL for the project.

All submissions should either be viewable standalone on standard browsers or hosted by yourself. No environment set up or software should be required to view the submission.

repository: amarginet-wp/wipro-digital

repo_name: amarginet-wp/wipro-digital


text:
# MultilayerAspnetProjectTemplate
A multilayer Asp.net MVC web app project template for Visual Studio 2015

It has all the components you need to start a structured, multi-layer Web Application based on Asp.Net MVC and .Net Framework v4.6.1 (with Entity Framework):

* Presentation Layer
  * Some useful Http and Ajax Helpers
  * Some basic model binders
  * Some useful Extension Methods
* Business Layer
  * Business Entities
  * Some useful Extension Methods
  * Some useful business objects Managers
  * Example of Business Logic
  * Example of "DAL Entity" to/from "Business Entity" Mapper
* Data Access Layer
  * DAL (DB) Entities
  * Generic and Typed Repositories
  * EF Context
  * Migrations
* Log Layer
  * Based on NLog
  * Extendible
* Simple unit test projects
  * Presentation layer tests
  * Business layer tests
  * Fake entities and helpers

# How to intall the template

It is very simple!
+ Grab the **MVCMultiLayer.Template.zip** and the **MVCMultiLayer.TemplateWizard.dll** files from the *"TemplatePackages"* folder
+ Copy the **zip** file to the *"C:\Users\YOUR_USERNAME\Documents\Visual Studio 2015\Templates\ProjectTemplates\Visual C#\"* folder
+ Register the **dll** library into the GAC with the command `gacutil /i MVCMultiLayer.TemplateWizard.dll`

# How to use the Project Template
After the template installation, just start Visual Studio 2015 and go to create a new C# Web project.
A new **"MVCMultiLayer"** item will appear in the list ;)

Read the "INFO.md" file to have more information on template generation and usage.

gha_language: C#


text:
# Be Chat

Chat Support Application

## Getting Started

To install, run this command and you're good to go.

```
npm run setup
```

repository: jcmlumacad/chat-app

repo_name: jcmlumacad/chat-app


text:
Poros Binary
============

The command line interface for the [Poros](https://github.com/dlasalle/poros)
library.

Requirements
------------

To compile Poros you will need `CMake` >= 2.8 and a C++ compiler supporting
`c++14`.

The `configure` script is currently written in `bash`, but `cmake` can be
invoked directly to build the library.

Building
--------

To just build the dynamic library execute:

```
$ ./configure && make
```

and `build/<os-arch>/bin/poros` will be built.

Running
-------

To partition a graph into five parts with Poros:

```
$ ./poros example.graph 5
```

repository: dlasalle/poros-bin

repo_name: dlasalle/poros-bin


text:
# fpvlaptracker

licensed under [MIT](LICENSE.md)

simple open source diy fpv vtx lap tracking system

## features
- standalone and network mode available
- uses your existing analog vtx to do the lap detection
- 48 channels supported
- networked mode supports up to 8 tracker units and comfortable access using web ui

## how does it work?
the tracker unit measures the video signal strength (rssi) of the selected video channel to detect laps. it has a stand alone mode for single participants or a network mode supporting multiple participants and a web ui. in standalone mode the tracker unit is controlled using bluetooth and a mobile app for configuration and single user race (e.g. practicing). the network mode is used with any hardware that can run the java software backend.

### app
the tracker unit is accessed using bluetooth and a mobile application (older version was creating an wifi ap and serving a webpage but that was horrible slow). using the app one can configure the unit or run single user races (e.g. practicing).

the application is available in the play store (only android right now, [play store](https://play.google.com/store/apps/details?id=de.warhog.fpvlaptracker)), the source is found [here](https://github.com/warhog/fpvlaptracker-app).

### standalone mode
the tracker can be used in standalone mode for single user races.

### network mode
in network mode the tracker connects to a host software using wifi. races and particpants can be organized inside the host software. the host software includes a webserver that serves a web ui for watching / controlling races. parts of the ui are only accessible using a password (defaults to Admin/admin).

the web ui has websocket support for instant updates on laps and also can play sounds and text using the html5 api.

## tested devices
immersion rc vtx

blade inductrix fpv

boscam ts5828

eachine et526

tbs unify pro hv

betafpv 75s

## setup
[setup instructions](docs/setup.md)

## which hardware and software is used?
the hardware consists of a esp32 board with a boscam rx5808 receiver module connected. the esp32 runs the tracker firmware (written using Arduino software platform).
the backend of the race software for network mode was written in java using spring boot with jooq as database access
library. the frontend was developed using angularjs. the race software can be run on almost every platform that supports java se.

### why you have chosen that technology stack?
arduino because of its easy handling. spring-boot because it allows rapid and powerful webservice development and easy to set up (nothing needs to be installed). angularjs because i always wanted to use and try it out. sadly i started development before angular 2 was released. maybe i'll port it to a newer angular version someday. the mobile app is developed using ionic framework.

# repository information
this reposity contains the network mode components. the [fpvlaptracker-firmware](https://github.com/warhog/fpvlaptracker-firmware) repository contains the firmware sources. the [fpvlaptracker-hardware](https://github.com/warhog/fpvlaptracker-hardware) repository is containing all the hardware stuff for building an own tracker unit. The app can be found in the [fpvlaptracker-app](https://github.com/warhog/fpvlaptracker-app) repository.

## build instructions
you need gradle, npm and gulp installed. if these requirements are fulfilled you can easily
run "gradle build" from the command line to build the whole project.

[detailed build instructions](docs/build.md)

## build status
current status: ![build status image](https://travis-ci.org/warhog/fpvlaptracker.svg?branch=master)

## sound files used
_lap:_ [freesound](https://www.freesound.org/people/StaneStane/sounds/73560/)

texts: [fromtexttospeech.com](http://www.fromtexttospeech.com/)


text:
# Logging In

Upon navigating to the SanteDB iCDR administration panel for your deployment, the administration portal will challenge you for a login. The components of the login screen are illustrated below.

![](<../../../.gitbook/assets/image (423) (1) (1) (1) (1).png>)

* **Username Input**: This is a the security name which was created for your user. On a default installation of SanteDB the administrator account is `Administrator`. User names are case-insensitive, meaning `AdMiNiStRaToR` is equivalent to `administrator`.
* **Password Input:** This is the password which was provided to you by your administrator. The default password for a SanteDB installation is `Mohawk123`.
* **Login:** This button submits the authentication credentials you've entered to the identity provider and establishes a session for your account.
* **Forgot Password**: This button initiates a password reset operation.

## Forgot Password

To initiate the password reset workflow, click the `Forgot Password` button, this will open a new dialog which will permit the entry of a username.

![](<../../../.gitbook/assets/image (461).png>)

Next, enter the answer to the provided security challenge question.

![](<../../../.gitbook/assets/image (492).png>)

Finally, enter the new password for your user account, the password should adhere to the jurisdictions password complexity and history requirements.

![](<../../../.gitbook/assets/image (493).png>)

{% hint style="info" %}
Your jurisdiction may have enabled SMS or e-mail password reset mechanisms. If this is the case, you will receive an e-mail link or SMS code with a one time password for password reset.
{% endhint %}

repository: santedb/dev-doc

repo_name: santedb/dev-doc


text:
# Delete Disabled User Profiles
I work at a small hospital. Shared computers (ones at the nursing station for example), have a habit of running out of hard drive space. I created this script to get some of that space back.

## DisabledUsers.csv
At this small hospital, for auditing reasons, we keep all users that we disable for at least 1 year. At the time of disabling their account, they get moved to an OU called Disabled Users. I exported this list of users to a CSV and named it disabledusers.csv.

## The Script
The actual script is really simple. It looks up all current user profiles on the computer, uses the split command to get just the username, compares that username to each username in the CSV file, removing each one as it goes through the list.

## Future Versions
Eventually I want to make a version that doesn't rely on exporting a CSV, but for now, this one works.

url: https://raw.githubusercontent.com/bradleyherrin/PS-Scripts/cc5af881a206cae55f37e0b2008a893c9762fab4/Delete User Profiles From CSV/README.md

repository: bradleyherrin/PS-Scripts

repo_name: bradleyherrin/PS-Scripts


text:
# Contributing to True

True exists because of your contributions.
Bug reports and feature requests are welcome,
but code is even better!

In all cases,
we ask you to follow the
[Sass community guidelines](https://sass-lang.com/community-guidelines).

## Pull Requests

We use the `main` branch for production-ready code,
and side-branches for everything in-progress
or up-for-debate.

When submitting a patch via pull request:

- Write a clear, descriptive commit message
- Include any appropriate unit tests,
  and make sure all tests are passing (`yarn test`)
- Add your changes to the
  [changelog](https://github.com/oddbird/true/blob/main/CHANGELOG.md)
- Update or write appropriate [SassDoc](http://sassdoc.com/)
  inline documentation for your changes
- Keep it simple: one bug fix or feature per pull request

## Development

Set up your dev environment
with the appropriate dependencies:

```
yarn
```

## Committing

Linting and testing
should be done before every commit:

```
yarn commit
```

They can also be triggered individually:

```
# lint
yarn lint

# test with jest and true
yarn test

# compile sass tests
yarn build:sass
```

Once you've fixed any final errors or typos,
commit your changes, and submit a pull request!

repository: oddbird/true

gha_language: SCSS

repo_name: oddbird/true


text:
Visit https://github.com/asmichi/ChildProcess for the current development.
This repository has been archived as a reference for a ProcessPipeline implementation.

# Asmichi.ProcessPipeline
A .NET library that provides functionality for creating child processes. Easier, less error-prone, more flexible than `System.Diagnostics.Process` at creating child processes.

This library can be obtained via [NuGet](https://www.nuget.org/packages/Asmichi.ProcessPipeline/).

[![Build Status](https://dev.azure.com/asmichi/ProcessPipeline/_apis/build/status/ProcessPipeline-CI?branchName=master)](https://dev.azure.com/asmichi/ProcessPipeline/_build/latest?definitionId=2&branchName=master)

## Comparison with `System.Diagnostics.Process`

- Concentrates on creating a child process and obtaining its output.
    - Cannot query status of a process.
- More destinations of redirection:
    - NUL
    - File (optionally appended)
    - Pipe
    - Handle
- Less error-prone default values for redirection:
    - stdin to NUL
    - stdout to the current stdout
    - stderr to the current stderr
- Pipes are asynchronous; asynchronous reads and writes will be handled by IO completion ports.
- `WaitForExitAsync`.

# License

[The MIT License](LICENSE)

# Supported Runtimes

Frameworks:

- `net471` or later
- `netcoreapp2.1` or later
- (Will support frameworks that implement `netstandard2.1`)

Runtimes:

- `win10-x86` or later (Desktop)
- `win10-x64` or later (Desktop)

`linux-x64` support is planned but not implemented.

# Notes

- When overriding environment variables, it is recommended that you include basic environment variables such as `SystemRoot`, etc.

# Examples

See [ProcessPipeline.Example](src/ProcessPipeline.Example/) (not yet) for more examples.

## Basic

```cs
var si = new ChildProcessStartInfo("cmd", "/C", "echo", "foo")
{
    StdOutputRedirection = OutputRedirection.OutputPipe,
};

using (var p = ChildProcess.Start(si))
{
    using (var sr = new StreamReader(p.StandardOutput))
    {
        // "foo"
        Console.Write(await sr.ReadToEndAsync());
    }
    await p.WaitForExitAsync();
    // ExitCode: 0
    Console.WriteLine("ExitCode: {0}", p.ExitCode);
}
```

## Redirection to File

```cs
var si = new ChildProcessStartInfo("cmd", "/C", "set")
{
    StdOutputRedirection = OutputRedirection.File,
    StdOutputFile = "env.txt"
};

using (var p = ChildProcess.Start(si))
{
    await p.WaitForExitAsync();
}

// ALLUSERSPROFILE=C:\ProgramData
// ...
Console.WriteLine(File.ReadAllText("env.txt"));
```


text:
#Rhino - a Ruby ORM for HBase

Rhino is a Ruby object-relational mapping (ORM) for [HBase](http://www.hbase.org).

## Support & contact

Author: Quinn Slack qslack<EMAIL_ADDRESS>
Contributors: Dru Jensen

## Getting started

### Installing HBase and Thrift

Since Rhino uses the HBase Thrift API, you must first install both HBase and Thrift. Downloading the latest trunk revisions of each is recommended, but if you encounter problems, try using the latest stable release instead. Here are the basic steps for installing both:

	#install hbase - this URL may change. to get the best URL, check http://www.apache.org/dyn/closer.cgi/hbase/
	wget http://mirrors.kahuki.com/apache//hbase/stable/hbase-0.90.3.tar.gz
	tar xvf hbase-0.90.3.tar.gz
	cd hbase-0.90.3
	cd ..

	#install thrift - this assumes that you already have boost installed
	wget http://www.apache.org/dyn/closer.cgi?path=/thrift/0.6.1/thrift-0.6.1.tar.gz
	tar xvf thrift-0.6.1.tar.gz
	cd thrift-0.6.1
	./configure
	make
	sudo make install
	cd ..

	#start hbase and hbase-thrift servers
	cd hbase-0.90.3
	bin/start-hbase.sh
	bin/hbase thrift start

TODO: set up an hbase server in ec2 so that the hbase install isn't needed

### Installing Rhino

Since Rhino is not yet packaged as a gem, you will have to run:

	git clone git@github.com:arschles/rhino.git

and then in your code:

	require 'rhino/lib/rhino.rb'

## Usage

### Connect to HBase

The following code points Rhino to the Thrift server you just started (which by default listens on localhost:9090).

  Rhino::Model.connect('localhost', 9090)

### Describe your table

A class definition like:

	class Page < Rhino::Model
		include Rhino::Constraints

		column_family :title
		column_family :contents
		column_family :links
		column_family :meta
		column_family :images

		alias_attribute :author, 'meta:author'

		has_many :links, Link
		has_many :images, Image

		constraint(:title_required) { |page| page.title and !page.title.empty? }
	end

is mapped to the following in the HBase shell language:

	create 'pages', 'title', 'contents', 'links', 'meta', 'images'

### Basic operations

#### Getting records

	page = Page.get('some-page')
	all_pages = Page.get_all()

#### Creating new records

	# data can be specified in the second argument of Page.new...
	page = Page.new('the-row-key', {:title=>"my title"})
	# ...or as attributes on the model
	page.contents = "
welcome
"
	page.save

#### Reading and updating attributes

	page = Page.get('some-key')
	puts "the old title is: #{page.title}"
	page.title = "another title"
	page.save
	puts "the new title is: #{page.title}"

You can also read from and write to specific columns in a column family.
Since we already defined the *meta:* column family, Rhino knows we want to set the *meta:author* column:

	page = Page.get('some-key')
	page.meta_author = "John Doe"
	page.save
	puts "the author is: #{page.meta_author}"

### has_many and belongs_to

In the model definition above, we stated that a Page *has_many :links* and *has_many :images*. We can
define what a Link and an Image is with greater detail now.

	class Link < Rhino::Cell
		belongs_to :page

		def url
			url_parts = key.split('/')
			backwards_host = url_parts.shift
			path = url_parts.join('/')
			host = backwards_host.split('.').reverse.join('.')
			"http://#{host}/#{path}"
		end
	end

	class Image < Rhino::Cell
		belongs_to :page
	end

Now that we've defined *Link* and *Image*, we can work with them easily. The following code adds a link to the page *com.example*, which when written to HBase becomes a cell in the *links:* column family named *links:com.google* with the contents *search engine*.

	page = Page.get('com.example')
	page.links.create('com.google', 'search engine')

You can also iterate over the collection of links. In this example, we use *Link#url*, a method we defined on the Link class
to convert from the common *com.example/path* URL storage style to *example.com/path*.

	page.links.each do |link|
		puts "Link to #{link.url} with text: '#{link.contents}'"
	end

You can also get a specific link.

	google_link_text = page.get('com.google').contents

### Setting timestamps and retrieving by timestamp

First, let's create some Pages with different timestamps.

	a_week_ago = Time.now - 7 * 24 * 3600
	a_month_ago = Time.now - 30 * 24 * 3600

	newer_page = Page.create('google.com', {:title=>'newer google'}, {:timestamp=>a_week_ago})
	older_page = Page.create('google.com', {:title=>'older google'}, {:timestamp=>a_month_ago})

Now you can *get* by the timestamps you just set.

	Page.get('google.com', :timestamp=>a_week_ago).title # => "newer google"
	Page.get('google.com', :timestamp=>a_month_ago).title # => "older google"

If you call *get* with no arguments, you will get the most recent Page.

	Page.get('google.com').title # => "newer google"

## More information

Read the specs in the spec/ directory to see more usage examples. Also look at the spec models in spec/spec_helper.rb. Note that to run the specs, you will need to create the necessary table and column
families in HBase before you continue. To do so, launch the HBase shell:

	$HBASE_DIR/bin/hbase shell

and execute:

	create 'pages', 'title', 'contents', 'links', 'meta', 'images'

## Notes to myself
* [HBase thrift docs](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/thrift/doc-files/Hbase.html)
* [HBase quick start](http://hbase.apache.org/quickstart.html)

repository: arschles/rhino

repo_name: arschles/rhino


text:
# Prototypes
> Dinamically add methods to PHP classes

[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/skrtdev/prototypes/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/skrtdev/prototypes/?branch=master) [![Build Status](https://scrutinizer-ci.com/g/skrtdev/prototypes/badges/build.png?b=master)](https://scrutinizer-ci.com/g/skrtdev/prototypes/build-status/master) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/ab3a826ec45e45d7bcc910c39df1331a)](https://www.codacy.com/gh/skrtdev/prototypes/dashboard?utm_source=github.com&utm_medium=referral&utm_content=skrtdev/prototypes&utm_campaign=Badge_Grade) ![php version](https://img.shields.io/badge/php-%3E%3D7.4-blueviolet)
Using this library you can dinamcally add methods to classes, as in the following example:
```php
use skrtdev\Prototypes\Prototypeable;

class MyClass{
    use Prototypeable;
}

MyClass::addMethod('wow', function () {
    return "What a nice way to use PHP";
});

$instance = new MyClass();

echo $instance->wow();
```
Output is `What a nice way to use PHP`

### Main Features

  - Closures are bound to the original object, so you can access `$this` inside closures in the same way as you do when writing a normal method for that class.
  - Supports **static** methods too, and you can access `self` and `static` too.
  - A native-like `\Error` will be thrown when trying to call a non-existent method.
  - A `skrtdev\Prototypes\Exception` will be thrown if class method already exists, is a prototype, class does not exist or isn't Prototypeable (when using `skrtdev\Prototypes\Prototypes::addMethod()`).
  - Ability to use any kind of `callable`s, not just `Closure`s.
  - Ability to use [named arguments](https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments) in Prototypes methods.

### Check if a Class is Prototypeable

You may need to know if a class is `Prototypeable` before trying to add methods to it.

You can use `isPrototypeable` method:
```php
use skrtdev\Prototypes\Prototypes;

var_dump(Prototypes::isPrototypeable($instance::class)); // you must pass the class name as string (use get_class() in php7.x)
var_dump(Prototypes::isPrototypeable(MyClass::class));
```

### Fun fact

The `Prototypes` class itself is `Prototypeable`, how strange.

### Known issues

  - This library does not have `Inheritance`: you won't be able to use Prototypes methods defined for a class in his child classes. (this is going to be added soon)
  - You can't override already-prototyped methods, but this will be added soon.
  - Any kind of `Error/Exception`(s) look a bit strange in the Stack traces, and method name is hidden. Maybe there is a solution; if you find it, feel free to open an `Issue/Pull Request`.

### Future scope

  - Use `class_parent()` to implement some kind of `Inheritance`. This may slow up calling prototypes in classes with a long hierarchy.
  - Maybe add the ability to add a method to a class without adding it to his children. (does it make sense?)
  - Allow to add all methods of a normal/anonymous class into a Prototypeable one (Using `Reflection`?).
  - Add the ability to define prototype methods that has been already defined as prototypes, overwriting them.
  - Add the ability to define prototypes for all the Prototypeable classes. (do you see any use cases?)

repository: FraSharp/FraSharpBot

repo_name: FraSharp/FraSharpBot


text:
\mainpage Main Page

---
# DC Motor 2 click

<DC MOTOR 2 click carries the TB6593FNG driver IC for direct current motors. With two pairs of screw terminals (power supply and outputs), the click board can drive motors with voltages from 2.5 to 13V (output current of up to 1.2 amps with peaks up to 3.2 amps) . The PWM signal drives the motor while the IN1 and IN2 pins provide binary direction signals that set the direction of the motor (clockwise or counter clockwise), or apply stop or short brake functions.>

[click Product page](https://www.mikroe.com/dc-motor-2-click)

---

#### Click library

- **Author**        : MikroE Team
- **Date**          : Jan 2020.
- **Type**          : PWM type

# Software Support

We provide a library for the DcMotor2 Click
as well as a demo application (example), developed using MikroElektronika
[compilers](https://shop.mikroe.com/compilers).
The demo can run on all the main MikroElektronika [development boards](https://shop.mikroe.com/development-boards).

Package can be downloaded/installed directly form compilers IDE(recommended way), or downloaded from our LibStock, or found on mikroE github account.

## Library Description

> This library contains API for DcMotor2 Click driver.

#### Standard key functions :

- Config Object Initialization function.
> void dcmotor2_cfg_setup ( dcmotor2_cfg_t *cfg );

- Initialization function.
> DCMOTOR2_RETVAL dcmotor2_init ( dcmotor2_t *ctx, dcmotor2_cfg_t *cfg );

- Click Default Configuration function.
> void dcmotor2_default_cfg ( dcmotor2_t *ctx );

#### Example key functions :

- This function sets the IN1/IN2 pins to 0/1 and makes the motor spin counter
  clockwise.
> void dcmotor2_spin_counter_clockwise ( dcmotor2_t *ctx );

- This function sets the IN1/IN2 pins to 1/0 and makes the motor spin clockwise.
> void dcmotor2_spin_clockwise ( dcmotor2_t *ctx );

- This function sets the IN1/IN2 pins to 1/1 and forces the motor to break.
> void dcmotor2_pull_brake ( dcmotor2_t *ctx );

- This function sets the IN1/IN2 pins to 0/0 and stops the motor completely.
> void dcmotor2_stop_motor ( dcmotor2_t *ctx );

## Examples Description

> This example showcases how to initialize and use the DC Motor 2 click. The click contains a
  Driver IC for DC motors which can spin the motor clockwise, counter-clockwise, break it and
  completely stop the motor. The example needs a DC motor and a power supply in order to work.

**The demo application is composed of two sections :**

### Application Init

> This function initializes and configures the logger and click modules.

```c

void application_init ( )
{
    log_cfg_t log_cfg;
    dcmotor2_cfg_t cfg;

    //  Logger initialization.

    LOG_MAP_USB_UART( log_cfg );
    log_cfg.level = LOG_LEVEL_DEBUG;
    log_cfg.baud = 9600;
    log_init( &logger, &log_cfg );
    log_info( &logger, "---- Application Init ----" );
    Delay_100ms( );

    //  Click initialization.

    dcmotor2_cfg_setup( &cfg );
    DCMOTOR2_MAP_MIKROBUS( cfg, MIKROBUS_1 );
    Delay_100ms( );
    dcmotor2_init( &dcmotor2, &cfg );
    dcmotor2_pwm_start( &dcmotor2 );
    Delay_1sec( );
}

```

### Application Task

> This function breaks the motor, starts spinning it clockwise and changes the rotation speed
  from min to max, breaks the motor again and spins it counter clockwise from max speed to min.
  It waits for one second after each action.

```c

void application_task ( )
{
    dcmotor2_enable_motor( &dcmotor2 );
    Delay_1sec( );

    clockwise( );
    pull_brake( );
    counter_clockwise( );
    pull_brake( );

    dcmotor2_stop_motor( &dcmotor2 );
    Delay_1sec( );
}

```

The full application code, and ready to use projects can be  installed directly form compilers IDE(recommneded) or found on LibStock page or mikroE GitHub accaunt.

**Other mikroE Libraries used in the example:**

- MikroSDK.Board
- MikroSDK.Log
- Click.DcMotor2

**Additional notes and informations**

Depending on the development board you are using, you may need
[USB UART click](https://shop.mikroe.com/usb-uart-click),
[USB UART 2 Click](https://shop.mikroe.com/usb-uart-2-click) or
[RS232 Click](https://shop.mikroe.com/rs232-click) to connect to your PC, for
development systems with no UART to USB interface available on the board. The
terminal available in all Mikroelektronika
[compilers](https://shop.mikroe.com/compilers), or any other terminal application
of your choice, can be used to read the message.

---


text:
---
previousText: 'Books'
previousUrl: '/docs/developer-resources/books'
nextText: 'Guides'
nextUrl: '/docs/developer-resources/guides'
---

# Courses

### [Elite Ionic](https://www.joshmorony.com/elite/)

by Josh Morony

### [Introducing Ionic 2](http://shop.oreilly.com/product/0636920050353.do)

by Mathieu Chauvinc

### [Building Mobile Apps with Ionic 2, Angular 2, and TypeScript](https://app.pluralsight.com/library/courses/ionic2-angular2-typescript-mobile-apps/table-of-contents)

by Pluralsight

### [Ionic 2 Master Course](https://www.udemy.com/ionic-2-tutorial/)

by Udemy

### [Introducing Ionic 2](https://www.udemy.com/introducing-ionic-2/)

by Udemy

### [Ionic 2 Solutions](https://www.packtpub.com/web-development/ionic-2-solutions-video)

by Hoc Phan

repository: FdezRomero/ionic-docs

repo_name: FdezRomero/ionic-docs


text:
# changejson

![npm](https://img.shields.io/npm/v/changejson.svg) ![license](https://img.shields.io/badge/license-MIT-blue.svg) ![github-issues](https://img.shields.io/github/issues/SSK001/changejson.svg)

Function's to manipulate JSON for easy access.

[![NPM](https://nodei.co/npm/changejson.png?compact=true)](https://nodei.co/npm/changejson/)

## Features

 - Change the schema of the Json
 - Compare and count's the keys
 - Merge the same keys

## Change the schema of the Json

 - This function will input the object, schema. returned object will be in the schema that is specified.
 - Input:
   ```
   console.log(JSON.stringify(changeJson.changeSchema(
      {
          'x': 1,
          'y': 2
      },
      ['y','x']
      ),null,' ')
   ```
 - Output:
   ```
   {
     'y': 2,
     'x': 1
   }
   ```
## Compare and count's the keys

 - This function compares two objects are returns the intersection of keys
 - Input:
   ```
   console.log(cj.compareAndCount({'x':1},{'x':2,'y':2}))
   ```
 - Output:
   ```
   { compare: [ 'x' ], count: 1 }
   ```

## Merge the same keys

 - You can pass in an array of objects and get out a single object, with all the keys from every object and an array of the values
 - Input:
   ```
   console.log(merge([
        {"first_name":"Frank", "last_name":"Billy", "friends":["Pam", "Susy"]},
        {"first_name":"Sally", "last_name":"Doe", "middle_name":"Krissy", "friends":["Rick", "Walter"]},
        {"first_name":"Don"}
    ]))
   ```
 - Output:
   ```
   { first_name: [ 'Frank', 'Sally', 'Don' ],
      last_name: [ 'Billy', 'Doe' ],
      friends: [ 'Pam', 'Susy', 'Rick', 'Walter' ],
      middle_name: [ 'Krissy' ] }
   ```


text:
# swsh

[![CI tests (static)][ci-badge-static]
 ![CI tests (macOS)][ci-badge-mac]
 ![CI tests (linux)][ci-badge-linux]
][ci-tests]
[![documentation][docs-badge]][docs]
[![coverage][cov-badge]][cov]

A shell-scripting library for Swift, inspired by [scsh][scsh].

swsh makes writing shell scripts more fun by exchanging bash (or similar) for a better thought-out language like Swift. In the process,
a small amount of conciseness is traded for better quoting, error handling, and access to libraries.

Some toy examples:
```swift
import swsh

let rot13 = cmd("tr", "a-z", "n-za-m")
try! rot13.input("secret message").runString()
// -> "frperg zrffntr"

try! (rot13.input("secret") | rot13).runString()
// -> "secret"
try! (rot13 | rot13).input("secret").runString()
// -> "secret"

try! (cmd("ls") | cmd("sort", "-n")).runLines()
// -> ["1.sh", "9.sh", "10.sh"]

["hello", "world", ""].map { cmd("test", "-z", $0).runBool() }
// -> [false, false, true]

try! (cmd("false") | cmd("cat")).run()
// Fatal error: 'try!' expression unexpectedly raised an error: command "false" failed with exit code 1
```

[Full documentation][docs]

## Acknowledgements
I would like to thank the same people that scsh does.

[ci-tests]: https://github.com/cobbal/swsh/actions?query=branch%3Amaster
[docs]: https://cobbal.github.io/swsh/
[cov]: https://codecov.io/gh/cobbal/swsh
[scsh]: https://scsh.net/

[ci-badge-static]: https://github.com/cobbal/swsh/workflows/test-static/badge.svg
[ci-badge-mac]: https://github.com/cobbal/swsh/workflows/test-mac/badge.svg
[ci-badge-linux]: https://github.com/cobbal/swsh/workflows/test-linux/badge.svg
[docs-badge]: https://cobbal.github.io/swsh/badge.svg
[cov-badge]: https://codecov.io/gh/cobbal/swsh/branch/master/graph/badge.svg

repository: cobbal/swsh

gha_language: Swift

repo_name: cobbal/swsh


text:
---
title: Scaling
---

# Scaling

Scaling options are used to quickly create scales in various places, like the
[Scale](../core/scales.md) component, the [Section](../core/section.md) component
and inside the [mapping object](../core/map.md#the-mapping-object).

## Options

### Defining and reusing

```js
{ scale: ... }
```

There are four ways to specify a scale:

- By passing an object of options
- By passing the name of a data column as a String
- By creating a scale in advance and referencing its String ID.
- By passing an Array.

The method of passing an object of options will be discussed under [Properties](#options).
The other two will be discussed under [Usage](#usage).

### Properties

| Property   | Required | Types             | Default   | Description                                                                               |
| ---------- | -------- | ----------------- | --------- | ----------------------------------------------------------------------------------------- |
| domain     | true     | [Array, String]   | undefined | Array containing domain boundaries, or a String referencing a column.                     |
| type       | false    | String            | depends   | Type of scale.                                                                            |
| domain-min | false    | Number            | undefined | Lower domain boundary. Used to overwrite `domain`.                                        |
| domain-max | false    | Number            | undefined | Upper domain boundary. Used to overwrite `domain`.                                        |
| domain-mid | false    | Number            | undefined | Mid-point of domain. Useful for creating diverging scales.                                |
| range-min  | false    | Number            | undefined | Lower range boundary. Used to overwrite chosen range.                                     |
| range-max  | false    | Number            | undefined | Upper range boundary. Used to overwrite chosen range.                                     |
| absolute   | false    | Boolean           | false     | Will treat negative values as positive.                                                   |
| reverse    | false    | Boolean           | false     | Will reverse the order of the scale/domain                                                |
| nice       | false    | [Boolean, Number] | true      | Extends the domain to start/stop on nice, round values. Boolean or the desired tick count |
| order      | false    | Array, Function   | undefined | For categorical domains: domain order                                                     |

##### domain

The `domain` is the only required scaling option. It can be specified as an Array or
as a String. When using an array, it is allowed to use

- An array of length 2 containing only Numbers
- An array of length > 1 containing only Strings
- An array of length 2 containing only Dates

These correspond to the quantitative, categorical and temporal data types.
When using a String, make sure the data column that is referenced contains one
of these types too. It is, for example, not allowed to use `grouped` columns.
As for `geometry` columns: using these is allowed as long as long as you clarify
whether you want to use the x or y domain. For example, `'geometry.x'` is allowed,
`'geometry'` is not. The x and/or y domains of the geometry will be treated as
quantitative.

##### type

When the `type` property is not specified, `vue-gg` will try its best to pick
a good scale by default. To make a good choice, it takes into account the `domain`
type (quantitative, categorical, temporal) and the `range` type (color, coordinate,
radius). The defaults for all combinations of `domain` and `range` types are
discussed under [Defaults](#defaults). The `type` property can be used to overwrite
these defaults, but make sure that you reference scales that are allowed for the
domain and range types in question (you cannot, for example, use `'linear'` when
using a categorical domain).

##### domainMin and domainMax

These can be used to overwrite the domain selected under `domain`. `domainMin` is
commonly used when creating bar charts, where the bar heights have to start at
zero instead of at the lowest value in the data.

##### domainMid

`domain-mid` will be used as a central point between the upper and lower boundaries
of the domain to create a [diverging](https://github.com/d3/d3-scale#diverging-scales)
scale.

##### rangeMin and rangeMax

When the `range-min` and `range-max` properties are not specified, `vue-gg` will
pick a range depending on the context where the scale is being created. When
the scale is used within the `scale-x` or `scale-y` props of a
[Section](../core/section.md), the range will be the dimensions of the Section
(for example, for `scale-x`, the values of the `[x1, x2]` props). The lower and
upper boundaries of this automatically determined range can then be manually
overwritten with respectively `range-min` and `range-max`.

##### absolute

This will treat all negative values that are passed through the scales as positive
values. Using `absolute` will also have effect on the domain. For example,
the column `[-5, -2, 1, 3, 4]`, which has domain `[-5, 4]`, will be treated as
`[5, 2, 1, 3, 4]`, with the domain `[1, 5]`. This domain can then again be
overwritten with `domain-min` and `domain-max`.

##### order

Adds ordering to categorical data. Can be specified as an Array with the
desired order, or as a Function that takes the chosen domain as first argument,
and returning a new Array with the desired order:

```js
// Array
{ scale: { domain: ..., order: ['apple', 'banana', 'pear'] } }

// Function
{ scale: { domain: ..., order: oldDomain => { oldDomain.sort(); return oldDomain } } }
```

Note that the new order will replace the existing domain. So data values not listed
in the new order will return `undefined`, which could cause errors for required props.

When using in combinat

### Defaults

See [prop types]() to see which props fall under
which types.

| Prop type  | quantitative | categorical | temporal | interval: quantitative |
| ---------- | ------------ | ----------- | -------- | ---------------------- |
| coordinate | linear       | equidistant | temporal | linear                 |
| color      | blues        | category10  | NA       | blues                  |
| opacity    | linear       | fullExtent  | NA       | fullExtent             |
| radius     | squareRoot   | fullExtent  | NA       | fullExtent             |
| other      | linear       | fullExtent  | NA       | fullExtent             |

## Usage

### Column name shorthand

A nice shorthand that will in many cases suffice is the 'column name' String.
Instead of passing an entire object, it is possible to just pass the name of the
column of which you want to use the domain:

::: v-pre
```html
<vgg-point :x="{ val: row.a, scale: 'a' }" />
```
:::

this will be converted to

::: v-pre
```html
<vgg-point :x="{ val: row.a, scale: { domain: 'a' } }" />
```
:::

### Referencing scales using `#`

The Scales component is used to create scales in one place,
which can then be referenced in other places. See the documentation of the
[Scales](../core/scales.md) component for more information.

### Using a domain Array

Setting a custom domain using an Array is commonly used in combination with
the [Section](../core/section.md) component.

repository: spatialnetworkslab/vue-gg

repo_name: spatialnetworkslab/vue-gg


text:
# TumblrDownload
Download a blog's liked posts to selected folder. (Sorry, Mac only)

## Usage:
1. First you need to [register an application on Tumblr](http://www.tumblr.com/oauth/apps), then you'll get a pair of "OAuth consumer key" and "Secret key". They are required later.
2. Fill in the OAuth consumer key in the application's "API key" text field.
3. Select your path to save all the files.
4. Fill in the Tumblr blog name.
5. Download!
6. You'll see a text file of downloaded posts in that folder. Use it later to unlike the posts within. But you first need to authorize the application to your blog and get two other keys: "OAuthToken" and "OAuthTokenSecret".

## Notes:

* It's very likely that the downloaded posts won't match the number of posts you liked. It seems like Tumblr's issue. (Tried to unlike all and still see likes but there is nothing within)
* The API key and directory are both stored locally, but the other three keys used to unlike posts are not saved.
* The OS will refuse to open the application because it's not signed. You can either hold Ctrl while opening the app or build the app yourself(recommended).

## ToDo:
* Download a blog's posts
* Download Text blog

License
----

MIT

repository: froyobin/TumblrDownload

repo_name: froyobin/TumblrDownload


text:
# Integration with the EGI Federated Cloud

[EGI](https://www.egi.eu/) is a federation of many cloud providers and
hundreds of data centres, spread across Europe and worldwide that delivers
advanced computing services to support scientists, multinational projects and
research infrastructures.

The [EGI Federated Cloud](https://www.egi.eu/federation/egi-federated-cloud/)
is an IaaS-type cloud, made of academic private clouds and virtualised
resources and built around open standards. Its development is driven by
requirements of the scientific communities.

## EGI Applications on Demand: IM Dashboard

The OSCAR platform can be deployed on the EGI Federated Cloud resources
through the [IM Dashboard](https://appsgrycap.i3m.upv.es:31443/im-dashboard/)
available in the
[EGI Applications on Demand](https://marketplace.egi.eu/42-applications-on-demand)
service.

The [IM Dashboard documentation](https://docs.egi.eu/users/compute/orchestration/im/dashboard/)
can be followed in order to deploy the platform.

![OSCAR on IM](images/oscar-egi-im.png)

## EGI DataHub

[EGI DataHub](https://datahub.egi.eu/), based on
[Onedata](https://onedata.org/#/home), provides a global data access solution
for science. Integrated with the EGI AAI, it allows users to have Onedata
spaces supported by providers across Europe for replicated storage and
on-demand caching.

EGI DataHub can be used as an output storage provider for OSCAR, allowing
users to store the resulting files of their OSCAR services on a Onedata
space. This can be done thanks to the
[FaaS Supervisor](https://github.com/grycap/faas-supervisor). Used in OSCAR
and [SCAR](https://github.com/grycap/scar), responsible for managing the data
Input/Output and the user code execution.

To deploy a function with Onedata as output storage provider you only have to
specify an identifier, the URL of the Oneprovider host, your access token and
the name of your Onedata space in the "Storage" tab of the service creation
wizard:

![Onedata provider](images/onedata-provider.png)

And the path where you want to store the files in the "OUTPUTS" tab:

![Onedata output](images/onedata-output.png)

This means that scientists can store their output files on their Onedata space
in the EGI DataHub for long-time persistence and easy sharing of experimental
results between researchers.

repository: grycap/oscar

gha_language: Go

repo_name: grycap/oscar


text:
---
title: "Navi GPS Case"
author: Creative
date: 2013-09-21
author_profile: true
layout: archive
excerpt: "Case for Garmin Nuvi GPS inspired by The Legend of Zelda."
header:
  teaser: https://emhastings.github.io/images/other/navi1.JPG
flexgallery:
  - aspect: "1.3333"
    url: https://emhastings.github.io/images/other/navi1.JPG
    image_path: https://emhastings.github.io/images/other/navi1-th.jpg
    alt: "Navi"
  - aspect: "1.3333"
    url: https://emhastings.github.io/images/other/navi2.JPG
    image_path: https://emhastings.github.io/images/other/navi2-th.jpg
    alt: "Navi"
    end_row: "true"

---

Case for my Garmin Nuvi GPS, featuring Navi from The Legend of Zelda: Ocarina of Time.

{% include flexgallery caption="" %}

## Documents and Links:
* [Blog post with construction details and more images](http://realmsoflegend.blogspot.com/2013/09/a-case-for-navi.html)


text:
# Retrieving IDs

First, you have to make sure you have developer mode is enabled.

User Settings → Advanced ("Behavior" in mobile clients) → look for Developer Mode.

![Developer Mode Desktop](https://cdn.discordapp.com/attachments/652544869314854934/862706211979001886/devmode_desktop.png) ![Developer Mode Mobile (Android)](https://cdn.discordapp.com/attachments/652544869314854934/862706213820432414/devmode_mobile.png)

A `Copy ID` button will be revealed in various context menus as you right-click (or tap and hold @ mobile users) on messages, channels, servers, users and roles.

![ID Fetch Hint](https://cdn.discordapp.com/attachments/652544869314854934/862709939427082290/get_entity_id_hint.gif)

repository: DevSpen/random-docs

repo_name: DevSpen/random-docs


text:
trabian-webapp-core
===================

Foundation for Trabian client-side web apps

This was recently extracted from Trabian's [webapp-prototype](https://github.com/trabian/webapp-prototype). We'll update this README shortly, but you can check out that project's README for now to understand the motivations behind it.

repository: trabian/trabian-webapp-core

gha_language: CoffeeScript

repo_name: trabian/trabian-webapp-core


text:
---
subcategory: "Application Firewall"
---

# Resource: appfwpolicy

The `appfwpolicy` resource is used to create Applicatin Firewall Policy resource.

## Example usage

``` hcl
resource citrixadc_appfwpolicy demo_appfwpolicy1 {
    name = "demo_appfwpolicy1"
    profilename = citrixadc_appfwprofile.demo_appfwprofile.name
    rule = "true"
}
resource citrixadc_appfwprofile demo_appfwprofile {
    name = "demo_appfwprofile"
    bufferoverflowaction = ["none"]
    contenttypeaction = ["none"]
    cookieconsistencyaction = ["none"]
    creditcard = ["none"]
    creditcardaction = ["none"]
    crosssitescriptingaction = ["none"]
    csrftagaction = ["none"]
    denyurlaction = ["none"]
    dynamiclearning = ["none"]
    fieldconsistencyaction = ["none"]
    fieldformataction = ["none"]
    fileuploadtypesaction = ["none"]
    inspectcontenttypes = ["none"]
    jsondosaction = ["none"]
    jsonsqlinjectionaction = ["none"]
    jsonxssaction = ["none"]
    multipleheaderaction = ["none"]
    sqlinjectionaction = ["none"]
    starturlaction = ["none"]
    type = ["HTML"]
    xmlattachmentaction = ["none"]
    xmldosaction = ["none"]
    xmlformataction = ["none"]
    xmlsoapfaultaction = ["none"]
    xmlsqlinjectionaction = ["none"]
    xmlvalidationaction = ["none"]
    xmlwsiaction = ["none"]
    xmlxssaction = ["none"]
}
```

## Argument Reference

* `name` - Name for the policy. Must begin with a letter, number, or the underscore character \(_\), and must contain only letters, numbers, and the hyphen \(-\), period \(.\) pound \(\#\), space \( \), at (@), equals \(=\), colon \(:\), and underscore characters. Can be changed after the policy is created. The following requirement applies only to the Citrix ADC CLI: If the name includes one or more spaces, enclose the name in double or single quotation marks \(for example, "my policy" or 'my policy'\).
* `rule` - (Optional) Name of the Citrix ADC named rule, or a Citrix ADC expression, that the policy uses to determine whether to filter the connection through the application firewall with the designated profile.
* `profilename` - (Optional) Name of the application firewall profile to use if the policy matches.
* `comment` - (Optional) Any comments to preserve information about the policy for later reference.
* `logaction` - (Optional) Where to log information for connections that match this policy.
* `newname` - (Optional) New name for the policy. Must begin with a letter, number, or the underscore character (_), and must contain only letters, numbers, and the hyphen (-), period (.) pound (#), space ( ), at (@), equals (=), colon (:), and underscore characters. The following requirement applies only to the Citrix ADC CLI: If the name includes one or more spaces, enclose the name in double or single quotation marks (for example, "my policy" or 'my policy').

## Attribute Reference

In addition to the arguments, the following attributes are available:

* `id` - The id of the `appfwpolicy`. It has the same value as the `name` attribute.

repository: citrix/terraform-provider-citrixadc

repo_name: citrix/terraform-provider-citrixadc


text:
# Chapter 4 File System

## Directories
1. Absolute File Path: The path from root to the file.

## File System Implementation
1. MBR: Master Boot Record, Sector 0 of the disk.
2. Implementing Files:
   1. Contiguous Allocation: May cause block and holes, UDF.
   2. Linked List Allocation
   3. Linked-List Allocation using a table in memory: FAT
   4. I-Node(Index-Node): The file stored in UNIX System is identified by INode Number.
3. Log-Structured File Systems:
   - Same author as Raft.
   - Every file is log and the file will be stored with several versions.
   - Require wrap file if the disk is full.
4. Journaling File Systems:
   - Use the concept of atomic transaction.

path: /Chap4 File System.md

filename: Chap4 File System.md


text:
{% comment %}
This file is licensed under the MIT License (MIT) available on
http://opensource.org/licenses/MIT.
{% endcomment %}
{% assign filename="_data/devdocs/en/bitcoin-core/rpcs/rpcs/getrawtransaction.md" %}

##### GetRawTransaction
{% include helpers/subhead-links.md %}

{% assign summary_getRawTransaction="return the raw transaction data." %}

{% autocrossref %}

The `getrawtransaction` RPC {{summary_getRawTransaction}}

By default this function only works for mempool transactions. When called with a blockhash
argument, getrawtransaction will return the transaction if the specified block is available and
the transaction is found in that block. When called without a blockhash argument, getrawtransaction
will return the transaction if it is in the mempool, or if -txindex is enabled and the transaction
is in a block in the blockchain.

Hint: Use gettransaction for wallet transactions.

If verbose is 'true', returns an Object with information about 'txid'.

If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.

*Parameter #1---txid*

{% itemplate ntpd1 %}
- n: "txid"
  t: "string"
  p: "Required
(exactly 1)"
  d: "The transaction id"

{% enditemplate %}

*Parameter #2---verbose*

{% itemplate ntpd1 %}
- n: "verbose"
  t: "boolean"
  p: "Optional
Default=false"
  d: "If false, return a string, otherwise return a json object"

{% enditemplate %}

*Parameter #3---blockhash*

{% itemplate ntpd1 %}
- n: "blockhash"
  t: "string"
  p: "Optional"
  d: "The block in which to look for the transaction"

{% enditemplate %}

*Result---(if verbose is not set or set to false)*

{% itemplate ntpd1 %}
- n: "`result`"
  t: "string (hex)"
  p: "Required
(exactly 1)"
  d: "The serialized, hex-encoded data for 'txid'"

{% enditemplate %}

*Result---(if verbose is set to true)*

{% endautocrossref %}

    {
      "in_active_chain": b, (bool) Whether specified block is in the active chain or not (only present with explicit "blockhash" argument)
      "hex" : "data",       (string) The serialized, hex-encoded data for 'txid'
      "txid" : "id",        (string) The transaction id (same as provided)
      "hash" : "id",        (string) The transaction hash (differs from txid for witness transactions)
      "size" : n,             (numeric) The serialized transaction size
      "vsize" : n,            (numeric) The virtual transaction size (differs from size for witness transactions)
      "weight" : n,           (numeric) The transaction's weight (between vsize*4-3 and vsize*4)
      "version" : n,          (numeric) The version
      "locktime" : ttt,       (numeric) The lock time
      "vin" : [               (array of json objects)
         {
           "txid": "id",    (string) The transaction id
           "vout": n,         (numeric)
           "scriptSig": {     (json object) The script
             "asm": "asm",  (string) asm
             "hex": "hex"   (string) hex
           },
           "sequence": n      (numeric) The script sequence number
           "txinwitness": ["hex", ...] (array of string) hex-encoded witness data (if any)
         }
         ,...
      ],
      "vout" : [              (array of json objects)
         {
           "value" : x.xxx,            (numeric) The value in BTC
           "n" : n,                    (numeric) index
           "scriptPubKey" : {          (json object)
             "asm" : "asm",          (string) the asm
             "hex" : "hex",          (string) the hex
             "reqSigs" : n,            (numeric) The required sigs
             "type" : "pubkeyhash",  (string) The type, eg 'pubkeyhash'
             "addresses" : [           (json array of string)
               "address"        (string) bitcoin address
               ,...
             ]
           }
         }
         ,...
      ],
      "blockhash" : "hash",   (string) the block hash
      "confirmations" : n,      (numeric) The confirmations
      "blocktime" : ttt         (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)
      "time" : ttt,             (numeric) Same as "blocktime"
    }

{% autocrossref %}

*Example*

{% highlight bash %}
bitcoin-cli getrawtransaction "mytxid"
{% endhighlight %}
{% highlight bash %}
bitcoin-cli getrawtransaction "mytxid" true
{% endhighlight %}
{% highlight bash %}
bitcoin-cli getrawtransaction "mytxid" false "myblockhash"
{% endhighlight %}
{% highlight bash %}
bitcoin-cli getrawtransaction "mytxid" true "myblockhash"
{% endhighlight %}

*See also*

* [GetTransaction][rpc gettransaction]: {{summary_getTransaction}}

{% endautocrossref %}


text:
# launch-contracts
Launch contracts for the SoulSwap Launch

## Contracts
[SoulStream.sol](https://testnet.ftmscan.com/address/0xaCa289be8DD6887BC5965815F8bD0AC1953b6Cb2#code): 0xaCa289be8DD6887BC5965815F8bD0AC1953b6Cb2

repository: SoulSwapFinance/launch-contracts

repo_name: SoulSwapFinance/launch-contracts


text:
# Dr.Quine
42 school project

## Concept:
A little application of the "fixed-point theorem".

So a "Quine" is a program who produces as output his own source code to self-reproduce himself.
Can be a useful introduction concept to metaprograming.

It's also a good prequel for malware projects.

## Useful links:
http://www.madore.org/~david/computers/quine.html

http://dwcope.freeshell.org/projects/quine/

repository: avallete/DrQuine

repo_name: avallete/DrQuine