text:
{{<layout}}

{{$pageTitle}}
  GOV.UK prototyping kit
{{/pageTitle}}

{{$propositionHeader}}
  {{>includes/propositional_navigation}}
{{/propositionHeader}}

{{$content}}

Home

Demand log

Assigned

Unassigned

Reports

Home > Demand log

  Demand log - Abby Carr

Basic search

Edit record

Assign resource

                  Name (read-only)
                  <input class="form-control" id="idoc" type="text" value="Abby Carr" readonly>

                  Initial date of contact (read-only)
                  <input class="form-control" id="idoc" type="text" value="02/09/2015" readonly>

              Email
              <input class="form-control" id="inital" type="text">

              Phone number
              <input class="form-control" id="inital" type="text">

                Location
                    <select class="select form-control">
                      <option>-- Please make a selection --</option>
                      <option value="Burnley">Burnley</option>
                      <option value="Leeds">Leeds</option>
                      <option value="London">London</option>
                      <option value="Manchester">Manchester</option>
                      <option value="Newcastle">Newcastle</option>

                    </select>

                  Project (read-only)
                  <input class="form-control" id="idoc" type="text" value="Access to Work" readonly>

                Methodology
                    <select class="select form-control">
                      <option>-- Please make a selection --</option>
                      <option value="Agile">Agile</option>
                      <option value="Waterfall">Waterfall</option>
                    </select>

                Phase
                    <select class="select form-control">
                      <option>-- Please make a selection --</option>
                      <option value="Discovery">Discovery</option>
                      <option value="Alpha">Alpha</option>
                      <option value="Beta">Beta</option>
                      <option value="Live">Live</option>
                    </select>

                Size
                    <select class="select form-control">
                      <option>-- Please make a selection --</option>
                      <option value="Small">Small</option>
                      <option value="Medium">Medium</option>
                      <option value="Large">Large</option>
                    </select>

        Submit

{{/content}}

{{/layout}}


text:
package com.blazebit.persistence.view.testsuite.update.flatview.nested.updatableonly.model;

import com.blazebit.persistence.testsuite.entity.Document;
import com.blazebit.persistence.view.CascadeType;
import com.blazebit.persistence.view.EntityView;
import com.blazebit.persistence.view.IdMapping;
import com.blazebit.persistence.view.UpdatableEntityView;
import com.blazebit.persistence.view.UpdatableMapping;

import java.util.List;
import java.util.Map;

/**
 *
 * @author Christian Beikov
 * @since 1.2.0
 */
@UpdatableEntityView
@EntityView(Document.class)
public interface UpdatableDocumentWithMapsView<T extends UpdatableNameObjectContainerView<? extends UpdatableNameObjectView>> {

    @IdMapping
    public Long getId();

    public String getName();

    public void setName(String name);

    @UpdatableMapping(updatable = true, cascade = { CascadeType.PERSIST, CascadeType.UPDATE })
    public Map<String, T> getNameContainerMap();

    public void setNameContainerMap(Map<String, T> nameContainerMap);

}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace spec\Brick\Routing;

use PhpSpec\ObjectBehavior;
use Prophecy\Argument;

require __DIR__ . '/../../../tests/Fixtures/AnnotatedController.php';

class AnnotationClassLoaderSpec extends ObjectBehavior
{
    /**
     * @param Doctrine\Common\Annotations\AnnotationReader $reader
     */
    function let($reader)
    {

        $this->beConstructedWith($reader);
    }

    function it_is_initializable()
    {
        $this->shouldHaveType('Brick\Routing\AnnotationClassLoader');
    }

    /**
     * @param Symfony\Component\Routing\Annotation\Route $annotation
     */
    function it_sets_the_constroller_based_on_reflection($annotation, $reader)
    {
        $reader->getMethodAnnotations(Argument::type('ReflectionMethod'))
            ->willReturn([$annotation]);

        $reader->getClassAnnotation(Argument::type('ReflectionClass'), 'Symfony\Component\Routing\Annotation\Route')
            ->willReturn([]);

        $annotation->getDefaults()->willReturn([]);
        $annotation->getRequirements()->willReturn([]);
        $annotation->getOptions()->willReturn([]);
        $annotation->getSchemes()->willReturn([]);
        $annotation->getMethods()->willReturn([]);
        $annotation->getHost()->willReturn();
        $annotation->getCondition()->willReturn();
        $annotation->getPath()->willReturn();
        $annotation->getName()->willReturn();

        $route = $this->load('Brick\Tests\Fixtures\AnnotatedController')
            ->get('brick_tests_fixtures_annotatedcontroller_helloaction');

        $route->getDefault('_controller')
            ->shouldReturn('Brick\Tests\Fixtures\AnnotatedController::helloAction');
    }

    /**
     * @param Brick\Annotation\Route $annotation
     */
    function it_sets_the_constroller_based_on_annotation_service($annotation, $reader)
    {
        $reader->getMethodAnnotations(Argument::type('ReflectionMethod'))
            ->willReturn([$annotation]);

        $reader->getClassAnnotation(Argument::type('ReflectionClass'), 'Symfony\Component\Routing\Annotation\Route')
            ->willReturn([]);

        $annotation->getDefaults()->willReturn([]);
        $annotation->getRequirements()->willReturn([]);
        $annotation->getOptions()->willReturn([]);
        $annotation->getSchemes()->willReturn([]);
        $annotation->getMethods()->willReturn([]);
        $annotation->getHost()->willReturn();
        $annotation->getCondition()->willReturn();
        $annotation->getPath()->willReturn();
        $annotation->getName()->willReturn();
        $annotation->getService()->willReturn('my_service_id');

        $route = $this->load('Brick\Tests\Fixtures\AnnotatedController')
            ->get('brick_tests_fixtures_annotatedcontroller_helloaction');

        $route->getDefault('_controller')
            ->shouldReturn('my_service_id:helloAction');
    }
}


text:
@implementation PluginStreetViewPanoramaController

//This is invoked every time the view.panorama property changes.
- (void)panoramaView:(GMSPanoramaView *)view didMoveToPanorama:(nullable GMSPanorama *)panorama {
  [self locationChangeEvent:panorama.coordinate];

}

// Called when the panorama change was caused by invoking moveToPanoramaNearCoordinate:.
- (void)panoramaView:(GMSPanoramaView *)view didMoveToPanorama:(nonnull GMSPanorama *)panorama nearCoordinate:(CLLocationCoordinate2D)coordinate {
  [self locationChangeEvent:coordinate];
}

// Called when moveNearCoordinate: produces an error.
- (void)panoramaView:(GMSPanoramaView *)view error:(nonnull NSError *)error onMoveNearCoordinate:(CLLocationCoordinate2D)coordinate {
  [self locationChangeEvent:coordinate];
}

// Called when moveToPanoramaID: produces an error.
- (void)panoramaView:(GMSPanoramaView *)view error:(nonnull NSError *)error onMoveToPanoramaID:(nonnull NSString *)panoramaID {
  [self locationChangeEvent:view.panorama.coordinate];
}

// Called repeatedly during changes to the camera on GMSPanoramaView.
- (void)panoramaView:(GMSPanoramaView *)view didMoveCamera:(nonnull GMSPanoramaCamera *)camera {

  NSMutableDictionary *cameraInfo = [NSMutableDictionary dictionary];
  [cameraInfo setObject:[NSNumber numberWithDouble:camera.orientation.heading] forKey:@"bearing"];
  [cameraInfo setObject:[NSNumber numberWithDouble:camera.orientation.pitch] forKey:@"tilt"];
  [cameraInfo setObject:[NSNumber numberWithDouble:camera.zoom] forKey:@"zoom"];

  NSData* jsonData = [NSJSONSerialization dataWithJSONObject:cameraInfo options:0 error:nil];
  NSString* sourceArrayString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
  NSString* jsString = [NSString
                        stringWithFormat:@"javascript:if('%@' in plugin.google.maps){plugin.google.maps['%@']({evtName: '%@', callback: '_onPanoramaCameraChange', args: [%@]});}",
                        self.overlayId, self.overlayId, @"panorama_camera_change", sourceArrayString];
  [self execJS:jsString];
}

// Called when a user has tapped on the GMSPanoramaView, but this tap was not consumed (taps may be consumed by e.g., tapping on a navigation arrow).
- (void)panoramaView:(GMSPanoramaView *)view didTap:(CGPoint)point {

  GMSOrientation svOrientation = [self.panoramaView orientationForPoint:point];

  NSMutableDictionary *clickInfo = [NSMutableDictionary dictionary];
  NSMutableDictionary *orientaion = [NSMutableDictionary dictionary];
  [orientaion setObject:[NSNumber numberWithDouble:svOrientation.heading] forKey:@"bearing"];
  [orientaion setObject:[NSNumber numberWithDouble:svOrientation.pitch] forKey:@"tilt"];
  [clickInfo setObject:orientaion forKey:@"orientation"];

  NSMutableArray *pointArray = [NSMutableArray array];
  [pointArray addObject:[NSNumber numberWithInt:point.x]];
  [pointArray addObject:[NSNumber numberWithInt:point.y]];
  [clickInfo setObject:pointArray forKey:@"point"];

  NSData* jsonData = [NSJSONSerialization dataWithJSONObject:clickInfo options:0 error:nil];
  NSString* sourceArrayString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
  NSString* jsString = [NSString
                        stringWithFormat:@"javascript:if('%@' in plugin.google.maps){plugin.google.maps['%@']({evtName: '%@', callback: '_onPanoramaEvent', args: [%@]});}",
                        self.overlayId, self.overlayId, @"panorama_click", sourceArrayString];
  [self execJS:jsString];

}

- (void) locationChangeEvent:(CLLocationCoordinate2D)coordinate {

  NSString* sourceArrayString = @"null";
  if (self.panoramaView.panorama) {
    NSMutableDictionary *location = [NSMutableDictionary dictionary];
    [location setObject:self.panoramaView.panorama.panoramaID forKey:@"panoId"];

    NSMutableDictionary *target = [NSMutableDictionary dictionary];
    [target setObject:[NSNumber numberWithDouble:coordinate.latitude] forKey:@"lat"];
    [target setObject:[NSNumber numberWithDouble:coordinate.longitude] forKey:@"lng"];
    [location setObject:target forKey:@"latLng"];

    NSMutableArray *links = [NSMutableArray array];
    for (GMSPanoramaLink *linkRef in self.panoramaView.panorama.links) {
      NSMutableDictionary *link = [NSMutableDictionary dictionary];
      [link setObject:linkRef.panoramaID forKey:@"panoId"];
      [link setObject:[NSNumber numberWithDouble:linkRef.heading] forKey:@"bearing"];
      [links addObject:link];
    }
    [location setObject:links forKey:@"links"];

    NSData* jsonData = [NSJSONSerialization dataWithJSONObject:location options:0 error:nil];
    sourceArrayString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
  }
  NSString* jsString = [NSString
                        stringWithFormat:@"javascript:if('%@' in plugin.google.maps){plugin.google.maps['%@']({evtName: '%@', callback: '_onPanoramaLocationChange', args: [%@]});}",
                        self.overlayId, self.overlayId, @"panorama_location_change", sourceArrayString];
  [self execJS:jsString];
}
@end


text:
class AsteroidBig : public Asteroid
{
public:
	AsteroidBig(BaseScene* scene) :
		Asteroid::Asteroid(scene)
	{}
	~AsteroidBig() {}

	void Initialize();
};


text:
package com.codeborne.selenide.commands;

import com.codeborne.selenide.Command;
import com.codeborne.selenide.ElementsCollection;
import com.codeborne.selenide.SelenideElement;
import com.codeborne.selenide.impl.BySelectorCollection;
import com.codeborne.selenide.impl.WebElementSource;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;

import static com.codeborne.selenide.commands.Util.firstOf;

@ParametersAreNonnullByDefault
public class FindAll implements Command<ElementsCollection> {
  @Override
  @CheckReturnValue
  @Nonnull
  public ElementsCollection execute(SelenideElement parentElement, WebElementSource parentLocator, @Nullable Object[] args) {
    Object selector = firstOf(args);
    return new ElementsCollection(
      new BySelectorCollection(parentLocator.driver(), parentLocator, WebElementSource.getSelector(selector))
    );
  }
}


text:
angular.module('MassAutoComplete', [])
.directive('massAutocomplete', ["$timeout", "$window", "$document", "$q", function ($timeout, $window, $document, $q) {
  'use strict';

  return {
    restrict: "A",
    scope: { options: '&massAutocomplete' },
    transclude: true,
    template:
      '' +
      '
 0" style="position:absolute;">' +
        '
' +
          '
 0" ' +
            'class="ac-menu-item" ng-class="$index == selected_index ? \'ac-state-focus\': \'\'">' +
            '' +
          '
' +
        '
' +
      '
',
    link: function (scope, element) {
      scope.container = angular.element(element[0].getElementsByClassName('ac-container')[0]);
    },
    controller: ["$scope", function ($scope) {
      var that = this;

      var KEYS = {
        TAB: 9,
        ESC: 27,
        ENTER: 13,
        UP: 38,
        DOWN: 40
      };

      var EVENTS = {
        KEYDOWN: 'keydown',
        RESIZE: 'resize',
        BLUR: 'blur'
      };

      var _user_options = $scope.options() || {};
      var user_options = {
        debounce_position: _user_options.debounce_position || 150,
        debounce_attach: _user_options.debounce_attach || 300,
        debounce_suggest: _user_options.debounce_suggest || 200,
        debounce_blur: _user_options.debounce_blur || 150
      };

      var current_element,
          current_model,
          current_options,
          previous_value,
          value_watch,
          last_selected_value;

      $scope.show_autocomplete = false;

      // Debounce - taken from underscore
      function debounce(func, wait, immediate) {
          var timeout;
          return function() {
              var context = this, args = arguments;
              var later = function() {
                  timeout = null;
                  if (!immediate) func.apply(context, args);
              };
              var callNow = immediate && !timeout;
              clearTimeout(timeout);
              timeout = setTimeout(later, wait);
              if (callNow) func.apply(context, args);
          };
      }

      function _position_autocomplete() {
        var rect = current_element[0].getBoundingClientRect(),
            scrollTop = $document[0].body.scrollTop || $document[0].documentElement.scrollTop || $window.pageYOffset,
            scrollLeft = $document[0].body.scrollLeft || $document[0].documentElement.scrollLeft || $window.pageXOffset,
            container = $scope.container[0];

        container.style.top = rect.top; // + rect.height + scrollTop + 'px';
        container.style.left = rect.left; // + scrollLeft + 'px';
        container.style.width = rect.width + 'px';
      }
      var position_autocomplete = debounce(_position_autocomplete, user_options.debounce_position);

      // Attach autocomplete behaviour to an input element.
      function _attach(ngmodel, target_element, options) {
        // Element is already attached.
        if (current_element === target_element) return;
        // Safe: clear previously attached elements.
        if (current_element) that.detach();
        // The element is still the active element.
        if (target_element[0] !== $document[0].activeElement) return;

        options.on_attach && options.on_attach();

        current_element = target_element;
        current_model = ngmodel;
        current_options = options;
        previous_value = ngmodel.$viewValue;

        $scope.results = [];
        $scope.selected_index = -1;
        bind_element();

        value_watch = $scope.$watch(
          function () {
            return ngmodel.$modelValue;
          },
          function (nv, ov) {
            // Prevent suggestion cycle when the value is the last value selected.
            // When selecting from the menu the ng-model is updated and this watch
            // is triggered. This causes another suggestion cycle that will provide as
            // suggestion the value that is currently selected - this is unnecessary.
            if (nv === last_selected_value)
              return;

            if ($scope.results)
              $scope.results.length = 0;

            _position_autocomplete();
            suggest(nv);
          }
        );
      };
      that.attach = debounce(_attach, user_options.debounce_attach);

      function _suggest(term) {
        $scope.selected_index = 0;
        $scope.show_autocomplete = false;
        $scope.waiting_for_suggestion = true;

        if (typeof(term) === 'string' && term.length > 0) {
          $q.when(current_options.suggest(term),
            function suggest_succeeded(suggestions) {
              // Add the original term as the first value to enable the user
              // to return to his original expression after suggestions were made.
              if (suggestions && suggestions.length > 0) {
                $scope.results = [{ value: term, label: ''}].concat(suggestions);
                $scope.show_autocomplete = true;
              } else {
                $scope.results = [];
              }
            },
            function suggest_failed(error) {
              current_options.on_error && current_options.on_error(error);
            }
          ).finally(function suggest_finally() {
            $scope.waiting_for_suggestion = false;
          });
        } else {
          $scope.waiting_for_suggestion = false;
          $scope.$apply();
        }
      };
      var suggest = debounce(_suggest, user_options.debounce_suggest);

      // Trigger end of editing and remove all attachments made by
      // this directive to the input element.
      that.detach = function () {
        if (current_element) {
          var value = current_element.val();
          update_model_value(value);
          current_options.on_detach && current_options.on_detach(value);
          current_element.unbind(EVENTS.KEYDOWN);
          current_element.unbind(EVENTS.BLUR);
        }

        // Clear references and events.
        $scope.show_autocomplete = false;
        angular.element($window).unbind(EVENTS.RESIZE);
        value_watch && value_watch();
        $scope.selected_index = $scope.results = undefined;
        current_model = current_element = previous_value = undefined;
      };

      // Update angular's model view value.
      // It is important that before triggering hooks the model's view
      // value will be synced with the visible value to the user. This will
      // allow the consumer controller to rely on its local ng-model.
      function update_model_value(value) {
        if (current_model.$modelValue !== value) {
          current_model.$setViewValue(value);
          current_model.$render();
        }
      }

      // Set the current selection while navigating through the menu.
      function set_selection(i) {
        // We use value instead of setting the model's view value
        // because we watch the model value and setting it will trigger
        // a new suggestion cycle.
        var selected = $scope.results[i];
        current_element.val(selected.value);
        $scope.selected_index = i;
        return selected;
      }

      // Apply and accept the current selection made from the menu.
      // When selecting from the menu directly (using click or touch) the
      // selection is directly applied.
      $scope.apply_selection = function (i) {
        current_element[0].focus();
        if (!$scope.show_autocomplete || i > $scope.results.length || i < 0)
          return;

        var selected = set_selection(i);
        last_selected_value = selected.value;
        update_model_value(selected.value);
        $scope.show_autocomplete = false;

        current_options.on_select && current_options.on_select(selected);
      };

      function bind_element() {
        angular.element($window).bind(EVENTS.RESIZE, position_autocomplete);

        current_element.bind(EVENTS.BLUR, function () {
          // Detach the element from the auto complete when input loses focus.
          // Focus is lost when a selection is made from the auto complete menu
          // using the mouse (or touch). In that case we don't want to detach so
          // we wait several ms for the input to regain focus.
          if (!$scope.show_autocomplete)
            $timeout(function() {
              if (!current_element || current_element[0] !== $document[0].activeElement)
                that.detach();
            }, user_options.debounce_blur);
        });

        current_element.bind(EVENTS.KEYDOWN, function (e) {
          // Reserve key combinations with shift for different purposes.
          if (e.shiftKey) return;

          switch (e.keyCode) {
            // Close the menu if it's open. Or, undo changes made to the value
            // if the menu is closed.
            case KEYS.ESC:
              if ($scope.show_autocomplete) {
                $scope.show_autocomplete = false;
                $scope.$apply();
              } else {
                current_element.val(previous_value);
              }
              break;

            // Select an element and close the menu. Or, if a selection is
            // unavailable let the event propagate.
            case KEYS.ENTER:
              // Accept a selection only if results exist, the menu is
              // displayed and the results are valid (no current request
              // for new suggestions is active).
              if ($scope.show_autocomplete &&
                  $scope.selected_index > 0 &&
                  !$scope.waiting_for_suggestion) {
                $scope.apply_selection($scope.selected_index);
                // When selecting an item from the AC list the focus is set on
                // the input element. So the enter will cause a keypress event
                // on the input itself. Since this enter is not intended for the
                // input but for the AC result we prevent propagation to parent
                // elements because this event is not of their concern. We cannot
                // prevent events from firing when the event was registered on
                // the input itself.
                e.stopPropagation();
              }

              $scope.show_autocomplete = false;
              $scope.$apply();
              break;

            // Navigate the menu when it's open. When it's not open fall back
            // to default behavior.
            case KEYS.TAB:
              if (!$scope.show_autocomplete)
                break;

              e.preventDefault();
              /* falls through */

            // Open the menu when results exists but are not displayed. Or,
            // select the next element when the menu is open. When reaching
            // bottom wrap to top.
            case KEYS.DOWN:
              if ($scope.results.length > 0) {
                if ($scope.show_autocomplete) {
                  set_selection($scope.selected_index + 1 > $scope.results.length - 1 ? 0 : $scope.selected_index + 1);
                } else {
                  $scope.show_autocomplete = true;
                  $scope.selected_index = 0;
                }
                $scope.$apply();
              }
              break;

            // Navigate up in the menu. When reaching the top wrap to bottom.
            case KEYS.UP:
              if ($scope.show_autocomplete) {
                e.preventDefault();
                set_selection($scope.selected_index - 1 >= 0 ? $scope.selected_index - 1 : $scope.results.length - 1);
                $scope.$apply();
              }
              break;
          }
        });
      }

      $scope.$on('$destroy', function () {
        that.detach();
        $scope.container.remove();
      });
    }]
  };
}])

.directive('massAutocompleteItem', function () {
  'use strict';

  return {
    restrict: "A",
    require: ["^massAutocomplete", "ngModel"],
    scope: false,
    link: function (scope, element, attrs, required) {
      // Prevent html5/browser auto completion.
      attrs.$set('autocomplete', 'off');

      element.bind('focus', function () {
        var options = scope[attrs.massAutocompleteItem];
        if (!options) throw "Invalid options";
        required[0].attach(required[1], element, options);
      });
    }
  };
});


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Taschenbestimmb. f. Pilze 2, Erysiphaceen (1926)

#### Original name
Podosphaera oxyacanthae f. cydoniae Jacz.

### Remarks
null


text:
package ontoplay.models.ontologyReading.jena.propertyFactories;

import ontoplay.models.ontologyModel.OntoProperty;
import ontoplay.models.ontologyReading.jena.OwlPropertyFactory;
import ontoplay.models.properties.IntegerProperty;

import com.hp.hpl.jena.ontology.OntProperty;

public class IntegerPropertyFactory extends OwlPropertyFactory {

	@Override
	public boolean canCreateProperty(OntProperty ontProperty) {
		if(!ontProperty.isDatatypeProperty())
			return false;
		if(ontProperty.getRange() == null)
			return false;
		if(ontProperty.getRange().getURI() == null)
			return false;

		String rangeUri = ontProperty.getRange().getURI();
		return rangeUri.equalsIgnoreCase("http://www.w3.org/2001/XMLSchema#integer") || rangeUri.equalsIgnoreCase("http://www.w3.org/2001/XMLSchema#int");
	}

	@Override
	public OntoProperty createProperty(OntProperty ontProperty) {
		return new IntegerProperty(ontProperty.getNameSpace(), ontProperty.getLocalName(), ontProperty.getRange().getURI(),ontProperty.getLabel(""));
	}

}


text:
from temboo.core.choreography import Choreography
from temboo.core.choreography import InputSet
from temboo.core.choreography import ResultSet
from temboo.core.choreography import ChoreographyExecution

import json

class ListDetails(Choreography):

    def __init__(self, temboo_session):
        """
        Create a new instance of the ListDetails Choreo. A TembooSession object, containing a valid
        set of Temboo credentials, must be supplied.
        """
        super(ListDetails, self).__init__(temboo_session, '/Library/Foursquare/Lists/ListDetails')

    def new_input_set(self):
        return ListDetailsInputSet()

    def _make_result_set(self, result, path):
        return ListDetailsResultSet(result, path)

    def _make_execution(self, session, exec_id, path):
        return ListDetailsChoreographyExecution(session, exec_id, path)

class ListDetailsInputSet(InputSet):
    """
    An InputSet with methods appropriate for specifying the inputs to the ListDetails
    Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
    """
    def set_Limit(self, value):
        """
        Set the value of the Limit input for this Choreo. ((optional, integer) Number of results to return, up to 500.)
        """
        super(ListDetailsInputSet, self)._set_input('Limit', value)
    def set_ListID(self, value):
        """
        Set the value of the ListID input for this Choreo. ((required, string) The id of a user-created or followed list or an id for a tip or todo in the form of USER_ID/tips or USER_ID/todos. When getting tips or todos for the acting user, the user id is not required.)
        """
        super(ListDetailsInputSet, self)._set_input('ListID', value)
    def set_OauthToken(self, value):
        """
        Set the value of the OauthToken input for this Choreo. ((required, string) The Foursquare API OAuth token string.)
        """
        super(ListDetailsInputSet, self)._set_input('OauthToken', value)
    def set_Offset(self, value):
        """
        Set the value of the Offset input for this Choreo. ((optional, integer) Used to page through results.)
        """
        super(ListDetailsInputSet, self)._set_input('Offset', value)
    def set_ResponseFormat(self, value):
        """
        Set the value of the ResponseFormat input for this Choreo. ((optional, string) The format that response should be in. Can be set to xml or json. Defaults to json.)
        """
        super(ListDetailsInputSet, self)._set_input('ResponseFormat', value)
    def set_UserID(self, value):
        """
        Set the value of the UserID input for this Choreo. ((optional, string) Identity of the user to get lists for. Defaults to "self" to get lists of the acting user.)
        """
        super(ListDetailsInputSet, self)._set_input('UserID', value)

class ListDetailsResultSet(ResultSet):
    """
    A ResultSet with methods tailored to the values returned by the ListDetails Choreo.
    The ResultSet object is used to retrieve the results of a Choreo execution.
    """

    def getJSONFromString(self, str):
        return json.loads(str)

    def get_Response(self):
        """
        Retrieve the value for the "Response" output from this Choreo execution. (The response from Foursquare. Corresponds to the ResponseFormat input. Defaults to JSON.)
        """
        return self._output.get('Response', None)

class ListDetailsChoreographyExecution(ChoreographyExecution):

    def _make_result_set(self, response, path):
        return ListDetailsResultSet(response, path)


text:
ActiveRecord::Schema.define(version: 20160502192937) do

  create_table "order_items", force: :cascade do |t|
    t.integer  "order_id",      null: false
    t.integer  "cantidad",      null: false
    t.string   "detalle",       null: false
    t.string   "unidad"
    t.string   "proveedor",     null: false
    t.text     "observaciones"
    t.datetime "created_at",    null: false
    t.datetime "updated_at",    null: false
  end

  add_index "order_items", ["order_id"], name: "index_order_items_on_order_id"

  create_table "orders", force: :cascade do |t|
    t.string   "nombres",       null: false
    t.string   "email",         null: false
    t.string   "organizacion"
    t.string   "telefono",      null: false
    t.string   "direccion",     null: false
    t.text     "observaciones"
    t.datetime "created_at",    null: false
    t.datetime "updated_at",    null: false
    t.string   "direccion_2"
    t.string   "cedula"
    t.integer  "user_id"
  end

  add_index "orders", ["user_id"], name: "index_orders_on_user_id"

  create_table "users", force: :cascade do |t|
    t.integer  "sign_in_count",      default: 0, null: false
    t.datetime "current_sign_in_at"
    t.datetime "last_sign_in_at"
    t.string   "current_sign_in_ip"
    t.string   "last_sign_in_ip"
    t.string   "provider"
    t.string   "uid"
    t.string   "name"
    t.text     "info"
    t.text     "credentials"
    t.datetime "created_at",                     null: false
    t.datetime "updated_at",                     null: false
    t.boolean  "admin"
  end

  add_index "users", ["admin"], name: "index_users_on_admin"
  add_index "users", ["provider", "uid"], name: "index_users_on_provider_and_uid"

  create_table "wamui_subscribers", force: :cascade do |t|
    t.string   "email"
    t.string   "slack"
    t.datetime "created_at", null: false
    t.datetime "updated_at", null: false
  end

end


text:
import Reflux from 'reflux';

export default {
    createAsyncActions: function(actionNames) {
        let actions = {};

        actionNames.map(actionName => {
            actions[actionName] = Reflux.createAction({
                children: ['started', 'completed', 'failure']
            });
        });

        return actions;
    }
};


text:
#include "vulkanexamplebase.h"
#include "VulkanglTFModel.h"

#define ENABLE_VALIDATION false

class VulkanExample : public VulkanExampleBase
{
public:
	vkglTF::Model model;
	vks::Buffer uniformBuffer;

	struct {
		glm::mat4 projection;
		glm::mat4 model;
		glm::mat4 view;
		int32_t texIndex = 0;
	} uboVS;

	VkPipelineLayout pipelineLayout;
	VkPipeline pipeline;
	VkDescriptorSetLayout descriptorSetLayout;
	VkDescriptorSet descriptorSet;

	bool screenshotSaved = false;

	VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
	{
		title = "Saving framebuffer to screenshot";
		camera.type = Camera::CameraType::lookat;
		camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 512.0f);
		camera.setRotation(glm::vec3(-25.0f, 23.75f, 0.0f));
		camera.setTranslation(glm::vec3(0.0f, 0.0f, -3.0f));
	}

	~VulkanExample()
	{
		vkDestroyPipeline(device, pipeline, nullptr);
		vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
		vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
		uniformBuffer.destroy();
	}

	void loadAssets()
	{
		model.loadFromFile(getAssetPath() + "models/chinesedragon.gltf", vulkanDevice, queue, vkglTF::FileLoadingFlags::PreTransformVertices | vkglTF::FileLoadingFlags::PreMultiplyVertexColors | vkglTF::FileLoadingFlags::FlipY);
	}

	void buildCommandBuffers()
	{
		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();

		VkClearValue clearValues[2];
		clearValues[0].color = defaultClearColor;
		clearValues[1].depthStencil = { 1.0f, 0 };

		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
		renderPassBeginInfo.renderPass = renderPass;
		renderPassBeginInfo.renderArea.offset.x = 0;
		renderPassBeginInfo.renderArea.offset.y = 0;
		renderPassBeginInfo.renderArea.extent.width = width;
		renderPassBeginInfo.renderArea.extent.height = height;
		renderPassBeginInfo.clearValueCount = 2;
		renderPassBeginInfo.pClearValues = clearValues;

		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
		{
			// Set target frame buffer
			renderPassBeginInfo.framebuffer = frameBuffers[i];

			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));

			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);

			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);

			VkRect2D scissor = vks::initializers::rect2D(width, height,	0, 0);
			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);

			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
			model.draw(drawCmdBuffers[i]);

			drawUI(drawCmdBuffers[i]);

			vkCmdEndRenderPass(drawCmdBuffers[i]);

			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
		}
	}

	void setupDescriptorPool()
	{
		std::vector<VkDescriptorPoolSize> poolSizes = {
			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
		};
		VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);
		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
	}

	void setupDescriptorSetLayout()
	{
		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),		// Binding 0: Vertex shader uniform buffer
		};
		VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));

		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
	}

	void setupDescriptorSet()
	{
		VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor),	// Binding 0: Vertex shader uniform buffer
		};
		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, nullptr);
	}

	void preparePipelines()
	{
		VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
		VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
		VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
		VkPipelineColorBlendStateCreateInfo colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
		VkPipelineDepthStencilStateCreateInfo depthStencilState = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
		VkPipelineViewportStateCreateInfo viewportState = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
		VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
		std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
		VkPipelineDynamicStateCreateInfo dynamicState = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables);

		std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = {
			loadShader(getShadersPath() + "screenshot/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT),
			loadShader(getShadersPath() + "screenshot/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT),
		};

		VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
		pipelineCI.pInputAssemblyState = &inputAssemblyState;
		pipelineCI.pRasterizationState = &rasterizationState;
		pipelineCI.pColorBlendState = &colorBlendState;
		pipelineCI.pMultisampleState = &multisampleState;
		pipelineCI.pViewportState = &viewportState;
		pipelineCI.pDepthStencilState = &depthStencilState;
		pipelineCI.pDynamicState = &dynamicState;
		pipelineCI.stageCount = shaderStages.size();
		pipelineCI.pStages = shaderStages.data();
		pipelineCI.pVertexInputState = vkglTF::Vertex::getPipelineVertexInputState({vkglTF::VertexComponent::Position, vkglTF::VertexComponent::Normal, vkglTF::VertexComponent::Color});
		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipeline));
	}

	void prepareUniformBuffers()
	{
		// Vertex shader uniform buffer block
		vulkanDevice->createBuffer(
			VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
			&uniformBuffer,
			sizeof(uboVS));
		VK_CHECK_RESULT(uniformBuffer.map());
		updateUniformBuffers();
	}

	void updateUniformBuffers()
	{
		uboVS.projection = camera.matrices.perspective;
		uboVS.view = camera.matrices.view;
		uboVS.model = glm::mat4(1.0f);
		uniformBuffer.copyTo(&uboVS, sizeof(uboVS));
	}

	// Take a screenshot from the current swapchain image
	// This is done using a blit from the swapchain image to a linear image whose memory content is then saved as a ppm image
	// Getting the image date directly from a swapchain image wouldn't work as they're usually stored in an implementation dependent optimal tiling format
	// Note: This requires the swapchain images to be created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT flag (see VulkanSwapChain::create)
	void saveScreenshot(const char *filename)
	{
		screenshotSaved = false;
		bool supportsBlit = true;

		// Check blit support for source and destination
		VkFormatProperties formatProps;

		// Check if the device supports blitting from optimal images (the swapchain images are in optimal format)
		vkGetPhysicalDeviceFormatProperties(physicalDevice, swapChain.colorFormat, &formatProps);
		if (!(formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT)) {
			std::cerr << "Device does not support blitting from optimal tiled images, using copy instead of blit!" << std::endl;
			supportsBlit = false;
		}

		// Check if the device supports blitting to linear images
		vkGetPhysicalDeviceFormatProperties(physicalDevice, VK_FORMAT_R8G8B8A8_UNORM, &formatProps);
		if (!(formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT)) {
			std::cerr << "Device does not support blitting to linear tiled images, using copy instead of blit!" << std::endl;
			supportsBlit = false;
		}

		// Source for the copy is the last rendered swapchain image
		VkImage srcImage = swapChain.images[currentBuffer];

		// Create the linear tiled destination image to copy to and to read the memory from
		VkImageCreateInfo imageCreateCI(vks::initializers::imageCreateInfo());
		imageCreateCI.imageType = VK_IMAGE_TYPE_2D;
		// Note that vkCmdBlitImage (if supported) will also do format conversions if the swapchain color format would differ
		imageCreateCI.format = VK_FORMAT_R8G8B8A8_UNORM;
		imageCreateCI.extent.width = width;
		imageCreateCI.extent.height = height;
		imageCreateCI.extent.depth = 1;
		imageCreateCI.arrayLayers = 1;
		imageCreateCI.mipLevels = 1;
		imageCreateCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
		imageCreateCI.samples = VK_SAMPLE_COUNT_1_BIT;
		imageCreateCI.tiling = VK_IMAGE_TILING_LINEAR;
		imageCreateCI.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
		// Create the image
		VkImage dstImage;
		VK_CHECK_RESULT(vkCreateImage(device, &imageCreateCI, nullptr, &dstImage));
		// Create memory to back up the image
		VkMemoryRequirements memRequirements;
		VkMemoryAllocateInfo memAllocInfo(vks::initializers::memoryAllocateInfo());
		VkDeviceMemory dstImageMemory;
		vkGetImageMemoryRequirements(device, dstImage, &memRequirements);
		memAllocInfo.allocationSize = memRequirements.size;
		// Memory must be host visible to copy from
		memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
		VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &dstImageMemory));
		VK_CHECK_RESULT(vkBindImageMemory(device, dstImage, dstImageMemory, 0));

		// Do the actual blit from the swapchain image to our host visible destination image
		VkCommandBuffer copyCmd = vulkanDevice->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);

		// Transition destination image to transfer destination layout
		vks::tools::insertImageMemoryBarrier(
			copyCmd,
			dstImage,
			0,
			VK_ACCESS_TRANSFER_WRITE_BIT,
			VK_IMAGE_LAYOUT_UNDEFINED,
			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VkImageSubresourceRange{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 });

		// Transition swapchain image from present to transfer source layout
		vks::tools::insertImageMemoryBarrier(
			copyCmd,
			srcImage,
			VK_ACCESS_MEMORY_READ_BIT,
			VK_ACCESS_TRANSFER_READ_BIT,
			VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
			VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VkImageSubresourceRange{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 });

		// If source and destination support blit we'll blit as this also does automatic format conversion (e.g. from BGR to RGB)
		if (supportsBlit)
		{
			// Define the region to blit (we will blit the whole swapchain image)
			VkOffset3D blitSize;
			blitSize.x = width;
			blitSize.y = height;
			blitSize.z = 1;
			VkImageBlit imageBlitRegion{};
			imageBlitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			imageBlitRegion.srcSubresource.layerCount = 1;
			imageBlitRegion.srcOffsets[1] = blitSize;
			imageBlitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			imageBlitRegion.dstSubresource.layerCount = 1;
			imageBlitRegion.dstOffsets[1] = blitSize;

			// Issue the blit command
			vkCmdBlitImage(
				copyCmd,
				srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
				dstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
				1,
				&imageBlitRegion,
				VK_FILTER_NEAREST);
		}
		else
		{
			// Otherwise use image copy (requires us to manually flip components)
			VkImageCopy imageCopyRegion{};
			imageCopyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			imageCopyRegion.srcSubresource.layerCount = 1;
			imageCopyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
			imageCopyRegion.dstSubresource.layerCount = 1;
			imageCopyRegion.extent.width = width;
			imageCopyRegion.extent.height = height;
			imageCopyRegion.extent.depth = 1;

			// Issue the copy command
			vkCmdCopyImage(
				copyCmd,
				srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
				dstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
				1,
				&imageCopyRegion);
		}

		// Transition destination image to general layout, which is the required layout for mapping the image memory later on
		vks::tools::insertImageMemoryBarrier(
			copyCmd,
			dstImage,
			VK_ACCESS_TRANSFER_WRITE_BIT,
			VK_ACCESS_MEMORY_READ_BIT,
			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
			VK_IMAGE_LAYOUT_GENERAL,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VkImageSubresourceRange{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 });

		// Transition back the swap chain image after the blit is done
		vks::tools::insertImageMemoryBarrier(
			copyCmd,
			srcImage,
			VK_ACCESS_TRANSFER_READ_BIT,
			VK_ACCESS_MEMORY_READ_BIT,
			VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
			VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VK_PIPELINE_STAGE_TRANSFER_BIT,
			VkImageSubresourceRange{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 });

		vulkanDevice->flushCommandBuffer(copyCmd, queue);

		// Get layout of the image (including row pitch)
		VkImageSubresource subResource { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0 };
		VkSubresourceLayout subResourceLayout;
		vkGetImageSubresourceLayout(device, dstImage, &subResource, &subResourceLayout);

		// Map image memory so we can start copying from it
		const char* data;
		vkMapMemory(device, dstImageMemory, 0, VK_WHOLE_SIZE, 0, (void**)&data);
		data += subResourceLayout.offset;

		std::ofstream file(filename, std::ios::out | std::ios::binary);

		// ppm header
		file << "P6\n" << width << "\n" << height << "\n" << 255 << "\n";

		// If source is BGR (destination is always RGB) and we can't use blit (which does automatic conversion), we'll have to manually swizzle color components
		bool colorSwizzle = false;
		// Check if source is BGR
		// Note: Not complete, only contains most common and basic BGR surface formats for demonstration purposes
		if (!supportsBlit)
		{
			std::vector<VkFormat> formatsBGR = { VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SNORM };
			colorSwizzle = (std::find(formatsBGR.begin(), formatsBGR.end(), swapChain.colorFormat) != formatsBGR.end());
		}

		// ppm binary pixel data
		for (uint32_t y = 0; y < height; y++)
		{
			unsigned int *row = (unsigned int*)data;
			for (uint32_t x = 0; x < width; x++)
			{
				if (colorSwizzle)
				{
					file.write((char*)row+2, 1);
					file.write((char*)row+1, 1);
					file.write((char*)row, 1);
				}
				else
				{
					file.write((char*)row, 3);
				}
				row++;
			}
			data += subResourceLayout.rowPitch;
		}
		file.close();

		std::cout << "Screenshot saved to disk" << std::endl;

		// Clean up resources
		vkUnmapMemory(device, dstImageMemory);
		vkFreeMemory(device, dstImageMemory, nullptr);
		vkDestroyImage(device, dstImage, nullptr);

		screenshotSaved = true;
	}

	void draw()
	{
		VulkanExampleBase::prepareFrame();

		submitInfo.commandBufferCount = 1;
		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));

		VulkanExampleBase::submitFrame();
	}

	void prepare()
	{
		VulkanExampleBase::prepare();
		loadAssets();
		prepareUniformBuffers();
		setupDescriptorSetLayout();
		preparePipelines();
		setupDescriptorPool();
		setupDescriptorSet();
		buildCommandBuffers();
		prepared = true;
	}

	virtual void render()
	{
		if (!prepared)
			return;
		draw();
	}

	virtual void viewChanged()
	{
		updateUniformBuffers();
	}

	virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay)
	{
		if (overlay->header("Functions")) {
			if (overlay->button("Take screenshot")) {
				saveScreenshot("screenshot.ppm");
			}
			if (screenshotSaved) {
				overlay->text("Screenshot saved as screenshot.ppm");
			}
		}
	}

};

VULKAN_EXAMPLE_MAIN()


text:
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2014 Wireless Communications and Networking Group (WCNG),
 * University of Rochester, Rochester, NY, USA.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Cristiano Tapparello <cristiano.tapparello@rochester.edu>
 */

#include "ns3/log.h"
#include "ns3/test.h"
#include "ns3/node.h"
#include "ns3/simulator.h"
#include "ns3/double.h"
#include "ns3/config.h"
#include "ns3/string.h"
#include "ns3/basic-energy-harvester.h"
#include "ns3/basic-energy-source.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("BasicEnergyHarvesterTestSuite");

class BasicEnergyHarvesterTestCase : public TestCase
{
public:
	BasicEnergyHarvesterTestCase ();
  ~BasicEnergyHarvesterTestCase ();

  void DoRun (void);

  double m_timeS;     // in seconds
  double m_tolerance; // tolerance for energy estimation

  ObjectFactory m_energySource;
  ObjectFactory m_energyHarvester;

};

BasicEnergyHarvesterTestCase::BasicEnergyHarvesterTestCase ()
  : TestCase ("Basic Energy Harvester test case")
{
	m_timeS = 15; // harvest energy for 15 seconds
	m_tolerance = 1.0e-13;  //
}

BasicEnergyHarvesterTestCase::~BasicEnergyHarvesterTestCase ()
{
}

void
BasicEnergyHarvesterTestCase::DoRun ()
{
	// set types
	m_energySource.SetTypeId ("ns3::BasicEnergySource");
	m_energyHarvester.SetTypeId ("ns3::BasicEnergyHarvester");
  // create node
  Ptr<Node> node = CreateObject<Node> ();

  // create Energy Source
  Ptr<BasicEnergySource> source = m_energySource.Create<BasicEnergySource> ();
  // aggregate Energy Source to the node
  node->AggregateObject (source);

  //create energy harvester
  Ptr<BasicEnergyHarvester> harvester = m_energyHarvester.Create<BasicEnergyHarvester> ();
  // Set the Energy Harvesting update interval to a value grater than the
  // simulation duration, so that the power provided by the harvester is constant
  harvester->SetHarvestedPowerUpdateInterval (Seconds (m_timeS + 1.0));
	// Connect the Basic Energy Harvester to the Energy Source
	source->ConnectEnergyHarvester (harvester);
	harvester->SetNode (node);
	harvester->SetEnergySource (source);

  Time now = Simulator::Now ();

  /*
	 * The energy harvester will recharge the energy source for m_timeS seconds.
	 */

  // Calculate remaining energy at simulation stop time
  Simulator::Schedule (Seconds (m_timeS),
                       &BasicEnergySource::UpdateEnergySource, source);

  double timeDelta = 0.000000001; // 1 nanosecond
  // run simulation; stop just after last scheduled event
  Simulator::Stop (Seconds (m_timeS + timeDelta));
  Simulator::Run ();

  // calculate energy harvested
  double estRemainingEnergy = source->GetInitialEnergy ();
  // energy = power * time
  estRemainingEnergy += harvester->GetPower () * m_timeS;

  // obtain remaining energy from source
	double remainingEnergy = source->GetRemainingEnergy ();
	NS_LOG_DEBUG ("Remaining energy is " << remainingEnergy);
	NS_LOG_DEBUG ("Estimated remaining energy is " << estRemainingEnergy);
	NS_LOG_DEBUG ("Difference is " << estRemainingEnergy - remainingEnergy);

	Simulator::Destroy ();

	// check remaining energy
  NS_TEST_ASSERT_MSG_EQ_TOL (remainingEnergy, estRemainingEnergy, m_tolerance,
                             "Incorrect Remaining energy!");

}

class BasicEnergyHarvesterTestSuite : public TestSuite
{
public:
  BasicEnergyHarvesterTestSuite ();
};

BasicEnergyHarvesterTestSuite::BasicEnergyHarvesterTestSuite ()
  : TestSuite ("basic-energy-harvester", UNIT)
{
  AddTestCase (new BasicEnergyHarvesterTestCase, TestCase::QUICK);
}

// create an instance of the test suite
static BasicEnergyHarvesterTestSuite g_basicEnergyHarvesterTestSuite;


text:
ActionController::Routing::Routes.draw do |map|
  map.adorable_otters(
    '/otters/adorable',
    { :controller => 'Otter', :action => 'adorable' })
end


text:
//
// BIM IFC export alternate UI library: this library works with Autodesk(R) Revit(R) to provide an alternate user interface for the export of IFC files from Revit.
// Copyright (C) 2012  Autodesk, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BIM.IFC.Export.UI
{
    /// <summary>
    /// The available user choices from the IFCExporter main export dialog.
    /// </summary>
    public enum IFCExportResult
    {
        /// <summary>
        /// Invalid selection before dialog is closed.
        /// </summary>
        Invalid,

        /// <summary>
        /// Export and save settings (if modified)
        /// </summary>
        ExportAndSaveSettings,

        /// <summary>
        /// Save settings but do not export
        /// </summary>
        SaveSettings,

        /// <summary>
        /// Cancel all changes
        /// </summary>
        Cancel
    }
}


text:
package android.support.v7.internal.view.menu;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.drawable.Drawable;
import android.support.v7.appcompat.R;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.TextView;

/**
 * The item view for each item in the ListView-based MenuViews.
 *
 * @hide
 */
public class ListMenuItemView extends LinearLayout implements MenuView.ItemView {

    private static final String TAG = "ListMenuItemView";
    private MenuItemImpl mItemData;

    private ImageView mIconView;
    private RadioButton mRadioButton;
    private TextView mTitleView;
    private CheckBox mCheckBox;
    private TextView mShortcutView;

    private Drawable mBackground;
    private int mTextAppearance;
    private Context mTextAppearanceContext;
    private boolean mPreserveIconSpacing;

    private int mMenuType;

    private Context mContext;
    private LayoutInflater mInflater;

    private boolean mForceShowIcon;

    public ListMenuItemView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs);
        mContext = context;

        TypedArray a =
                context.obtainStyledAttributes(
                        attrs, R.styleable.MenuView, defStyle, 0);

        mBackground = a.getDrawable(R.styleable.MenuView_android_itemBackground);
        mTextAppearance = a.getResourceId(R.styleable.
                MenuView_android_itemTextAppearance, -1);
        mPreserveIconSpacing = a.getBoolean(
                R.styleable.MenuView_android_preserveIconSpacing, false);
        mTextAppearanceContext = context;

        a.recycle();
    }

    public ListMenuItemView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();

        setBackgroundDrawable(mBackground);

        mTitleView = (TextView) findViewById(R.id.title);
        if (mTextAppearance != -1) {
            mTitleView.setTextAppearance(mTextAppearanceContext,
                    mTextAppearance);
        }

        mShortcutView = (TextView) findViewById(R.id.shortcut);
    }

    public void initialize(MenuItemImpl itemData, int menuType) {
        mItemData = itemData;
        mMenuType = menuType;

        setVisibility(itemData.isVisible() ? View.VISIBLE : View.GONE);

        setTitle(itemData.getTitleForItemView(this));
        setCheckable(itemData.isCheckable());
        setShortcut(itemData.shouldShowShortcut(), itemData.getShortcut());
        setIcon(itemData.getIcon());
        setEnabled(itemData.isEnabled());
    }

    public void setForceShowIcon(boolean forceShow) {
        mPreserveIconSpacing = mForceShowIcon = forceShow;
    }

    public void setTitle(CharSequence title) {
        if (title != null) {
            mTitleView.setText(title);

            if (mTitleView.getVisibility() != VISIBLE) {
                mTitleView.setVisibility(VISIBLE);
            }
        } else {
            if (mTitleView.getVisibility() != GONE) {
                mTitleView.setVisibility(GONE);
            }
        }
    }

    public MenuItemImpl getItemData() {
        return mItemData;
    }

    public void setCheckable(boolean checkable) {
        if (!checkable && mRadioButton == null && mCheckBox == null) {
            return;
        }

        // Depending on whether its exclusive check or not, the checkbox or
        // radio button will be the one in use (and the other will be otherCompoundButton)
        final CompoundButton compoundButton;
        final CompoundButton otherCompoundButton;

        if (mItemData.isExclusiveCheckable()) {
            if (mRadioButton == null) {
                insertRadioButton();
            }
            compoundButton = mRadioButton;
            otherCompoundButton = mCheckBox;
        } else {
            if (mCheckBox == null) {
                insertCheckBox();
            }
            compoundButton = mCheckBox;
            otherCompoundButton = mRadioButton;
        }

        if (checkable) {
            compoundButton.setChecked(mItemData.isChecked());

            final int newVisibility = checkable ? VISIBLE : GONE;
            if (compoundButton.getVisibility() != newVisibility) {
                compoundButton.setVisibility(newVisibility);
            }

            // Make sure the other compound button isn't visible
            if (otherCompoundButton != null && otherCompoundButton.getVisibility() != GONE) {
                otherCompoundButton.setVisibility(GONE);
            }
        } else {
            if (mCheckBox != null) {
                mCheckBox.setVisibility(GONE);
            }
            if (mRadioButton != null) {
                mRadioButton.setVisibility(GONE);
            }
        }
    }

    public void setChecked(boolean checked) {
        CompoundButton compoundButton;

        if (mItemData.isExclusiveCheckable()) {
            if (mRadioButton == null) {
                insertRadioButton();
            }
            compoundButton = mRadioButton;
        } else {
            if (mCheckBox == null) {
                insertCheckBox();
            }
            compoundButton = mCheckBox;
        }

        compoundButton.setChecked(checked);
    }

    public void setShortcut(boolean showShortcut, char shortcutKey) {
        final int newVisibility = (showShortcut && mItemData.shouldShowShortcut())
                ? VISIBLE : GONE;

        if (newVisibility == VISIBLE) {
            mShortcutView.setText(mItemData.getShortcutLabel());
        }

        if (mShortcutView.getVisibility() != newVisibility) {
            mShortcutView.setVisibility(newVisibility);
        }
    }

    public void setIcon(Drawable icon) {
        final boolean showIcon = mItemData.shouldShowIcon() || mForceShowIcon;
        if (!showIcon && !mPreserveIconSpacing) {
            return;
        }

        if (mIconView == null && icon == null && !mPreserveIconSpacing) {
            return;
        }

        if (mIconView == null) {
            insertIconView();
        }

        if (icon != null || mPreserveIconSpacing) {
            mIconView.setImageDrawable(showIcon ? icon : null);

            if (mIconView.getVisibility() != VISIBLE) {
                mIconView.setVisibility(VISIBLE);
            }
        } else {
            mIconView.setVisibility(GONE);
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mIconView != null && mPreserveIconSpacing) {
            // Enforce minimum icon spacing
            ViewGroup.LayoutParams lp = getLayoutParams();
            LayoutParams iconLp = (LayoutParams) mIconView.getLayoutParams();
            if (lp.height > 0 && iconLp.width <= 0) {
                iconLp.width = lp.height;
            }
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    private void insertIconView() {
        LayoutInflater inflater = getInflater();
        mIconView = (ImageView) inflater.inflate(R.layout.abc_list_menu_item_icon,
                this, false);
        addView(mIconView, 0);
    }

    private void insertRadioButton() {
        LayoutInflater inflater = getInflater();
        mRadioButton =
                (RadioButton) inflater.inflate(R.layout.abc_list_menu_item_radio,
                        this, false);
        addView(mRadioButton);
    }

    private void insertCheckBox() {
        LayoutInflater inflater = getInflater();
        mCheckBox =
                (CheckBox) inflater.inflate(R.layout.abc_list_menu_item_checkbox,
                        this, false);
        addView(mCheckBox);
    }

    public boolean prefersCondensedTitle() {
        return false;
    }

    public boolean showsIcon() {
        return mForceShowIcon;
    }

    private LayoutInflater getInflater() {
        if (mInflater == null) {
            mInflater = LayoutInflater.from(mContext);
        }
        return mInflater;
    }
}


text:
<menu xmlns:android="http://schemas.android.com/apk/res/android" >

    <item
        android:id="@+id/creditosMenuItem"
        android:showAsAction="never"
        android:icon="@android:drawable/ic_menu_help"
        android:title="@string/menu_credits"
    />

</menu>


text:
package org.apache.myfaces.ov2021.renderkit.html;

import java.io.IOException;
import java.util.List;

import javax.faces.component.UIComponent;
import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.render.Renderer;

import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFRenderer;
import org.apache.myfaces.shared_ext202patch.renderkit.html.HTML;
import org.apache.myfaces.shared_ext202patch.renderkit.html.HtmlRendererUtils;

/**
 * Renderer used by h:head component
 *
 * @since 2.0
 * @author Leonardo Uribe (latest modification by $Author: lu4242 $)
 * @version $Revision: 1229440 $ $Date: 2012-01-10 02:31:15 +0100 (Di, 10 Jän 2012) $
 */
@JSFRenderer(renderKitId = "HTML_BASIC", family = "javax.faces.Output", type = "javax.faces.Head")
public class HtmlHeadRenderer extends Renderer
{
    //TODO: Move constants to shared HTML class
    private final static String HEAD_ELEM = "head";
    private final static String HEAD_TARGET = HEAD_ELEM;

    private final static String PROFILE_ATTR = "profile";

    private final static String[] HEAD_PASSTHROUGH_ATTRIBUTES = { HTML.DIR_ATTR,
            HTML.LANG_ATTR, PROFILE_ATTR};

    @Override
    public void encodeBegin(FacesContext facesContext, UIComponent component)
            throws IOException
    {
        super.encodeBegin(facesContext, component); //check for NP

        ResponseWriter writer = facesContext.getResponseWriter();
        writer.startElement(HEAD_ELEM, component);
        HtmlRendererUtils.writeIdIfNecessary(writer, component, facesContext);
        HtmlRendererUtils.renderHTMLAttributes(writer, component,
                HEAD_PASSTHROUGH_ATTRIBUTES);
    }

    @Override
    public void encodeEnd(FacesContext facesContext, UIComponent component)
            throws IOException
    {
        super.encodeEnd(facesContext, component); //check for NP

        ResponseWriter writer = facesContext.getResponseWriter();
        UIViewRoot root = facesContext.getViewRoot();
        List<UIComponent> componentResources = root.getComponentResources(facesContext,
                HEAD_TARGET);

        for (int i = 0, childCount = componentResources.size(); i < childCount; i++)
        {
            UIComponent child = componentResources.get(i);
            child.encodeAll(facesContext);
        }
        writer.endElement(HEAD_ELEM);
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--Generated by crowdin.net-->
<!--
     Copyright (C) 2012-2014 The CyanogenMod Project

     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.
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
  <string name="application_copyright">Copyright \u00A9 2014 The CyanogenMod Project</string>
  <string name="X">X</string>
  <string name="Y">Y</string>
  <string name="arcsin">asin</string>
  <string name="arccos">acos</string>
  <string name="arctan">atan</string>
  <string name="dx">dX</string>
  <string name="dy">dY</string>
  <string name="solveForX">Risolvi in X</string>
  <string name="solveForY">Risolvi in Y</string>
  <string name="mod">mod</string>
  <string name="matrix">Pannello matrici</string>
  <string name="graph">Pannello grafici</string>
  <string name="function">Pannello funzioni</string>
  <string name="hexPanel">Pannello esadecimale</string>
  <string name="lock">Blocca la pagina</string>
  <string name="unlock">Sblocca la pagina</string>
  <string name="info">Info</string>
  <string name="copy">Copia \"%s\"</string>
  <string name="remove_from_history">Rimuovi dalla cronologia</string>
  <string name="showHistory">Mostra cronologia</string>
  <string name="hideHistory">Nascondi cronologia</string>
  <string name="settings">Impostazioni</string>
  <string name="det">det</string>
  <string name="eigenvalue">Autov.</string>
  <string name="solve">Risolvi</string>
  <string name="dotProduct">Scal.</string>
  <string name="crossProduct">Vett.</string>
  <string name="determinantDesc">Determinante</string>
  <string name="eigenvalueDesc">Autovalori</string>
  <string name="plus_row">+Righe</string>
  <string name="minus_row">-Righe</string>
  <string name="plus_col">+Col.</string>
  <string name="minus_col">-Col.</string>
  <string name="matrix_transpose">T</string>
  <string name="next">Prossimo</string>
  <string name="hex">Hex</string>
  <string name="bin">Bin</string>
  <string name="dec">Dec</string>
  <string name="hexDesc">Esadecimale</string>
  <string name="binDesc">Binario</string>
  <string name="decDesc">Decimale</string>
  <string name="pref_panels">Pannelli</string>
  <string name="pref_actions">Azioni</string>
  <string name="pref_units">Unità</string>
  <string name="pref_theme">Tema</string>
  <string name="pref_about">Info</string>
  <string name="returnToBasic">Ritorna al pannello base</string>
  <string name="infiniteScrolling">Scorrimento infinito</string>
  <string name="clickToOpenHistory">Clicca per la cronologia</string>
  <string name="digitGrouping">Raggruppamento cifre</string>
  <string name="trigUnits">Unità trigonometriche</string>
  <string name="radians">RAD</string>
  <string name="degrees">DEG</string>
  <string name="theme">Tema</string>
  <string name="showDetails">Mostra dettagli</string>
  <string name="floatingCalc">Calcolatrice fluttuante</string>
  <string name="vibrateOnPress">Vibra al tocco</string>
  <string name="showWidgetBackground">Visualizza sfondo widget</string>
  <string name="cling_simple_title">Benvenuto</string>
  <string name="cling_simple_msg">Scorrere verso sinistra e verso destra per accedere a più contenuti. Le pagine non necessarie possono essere disattivate nelle impostazioni.</string>
  <string name="cling_matrix_title">Matrici</string>
  <string name="cling_matrix_msg">Toccare qui per iniziare a costruire e risolvere matrici.</string>
  <string name="cling_hex_title">Cambia basi</string>
  <string name="cling_hex_msg">Passaggio tra decimale (dec), binario (bin), e esadecimale (hex).\n\nAttenzione:Se pensi di ottenere risultati errati, probabilmente sei nella base sbagliata. Il valore predefinito è decimale.</string>
  <string name="cling_graph_title">Grafico</string>
  <string name="cling_graph_msg">I grafici verranno automaticamente visualizzati qui. Andate al pannello avanzato e costruire una funzione che utilizza X e Y.</string>
  <string name="cling_dismiss">OK</string>
  <string name="bin_separator">\u0020</string>
  <string name="hex_separator">\u0020</string>
  <item name="dec_separator_distance" type="integer">3</item>
  <item name="bin_separator_distance" type="integer">4</item>
  <item name="hex_separator_distance" type="integer">2</item>
  <string name="dot">,</string>
  <string name="easter_egg">Magikarp usa Splash ma non succede nulla!</string>
  <string name="glass_start">Calcola</string>
  <string name="voice_detection_failed">Calcolo non riuscito. Riprovare?</string>
  <string name="voice_detection_repeat">Calcolare nuovamente?</string>
  <string name="speech_helper_negative" formatted="false">Negativo %s</string>
</resources>


text:
export function modules(state) {
  return state.modules;
}

export const moduleByName = (moduleName) => (state) => {
  return modules(state).get(moduleName);
};


text:
//=================================================================================================

//=================================================================================================

#ifndef _BLAZE_MATH_SHIMS_H_
#define _BLAZE_MATH_SHIMS_H_

//*************************************************************************************************
// Includes
//*************************************************************************************************

#include <blaze/math/shims/Abs.h>
#include <blaze/math/shims/Acos.h>
#include <blaze/math/shims/Acosh.h>
#include <blaze/math/shims/Arg.h>
#include <blaze/math/shims/Asin.h>
#include <blaze/math/shims/Asinh.h>
#include <blaze/math/shims/Atan.h>
#include <blaze/math/shims/Atan2.h>
#include <blaze/math/shims/Atanh.h>
#include <blaze/math/shims/Cbrt.h>
#include <blaze/math/shims/Ceil.h>
#include <blaze/math/shims/Clamp.h>
#include <blaze/math/shims/Clear.h>
#include <blaze/math/shims/Conjugate.h>
#include <blaze/math/shims/Cos.h>
#include <blaze/math/shims/Cosh.h>
#include <blaze/math/shims/Digits.h>
#include <blaze/math/shims/Equal.h>
#include <blaze/math/shims/Erf.h>
#include <blaze/math/shims/Erfc.h>
#include <blaze/math/shims/Eval.h>
#include <blaze/math/shims/Evaluate.h>
#include <blaze/math/shims/Exp.h>
#include <blaze/math/shims/Exp2.h>
#include <blaze/math/shims/Exp10.h>
#include <blaze/math/shims/Floor.h>
#include <blaze/math/shims/Frexp.h>
#include <blaze/math/shims/Greater.h>
#include <blaze/math/shims/Hypot.h>
#include <blaze/math/shims/Imaginary.h>
#include <blaze/math/shims/InvCbrt.h>
#include <blaze/math/shims/Invert.h>
#include <blaze/math/shims/InvSqrt.h>
#include <blaze/math/shims/IsDefault.h>
#include <blaze/math/shims/IsDivisor.h>
#include <blaze/math/shims/IsFinite.h>
#include <blaze/math/shims/IsInf.h>
#include <blaze/math/shims/IsNaN.h>
#include <blaze/math/shims/IsOne.h>
#include <blaze/math/shims/IsReal.h>
#include <blaze/math/shims/IsZero.h>
#include <blaze/math/shims/Less.h>
#include <blaze/math/shims/LGamma.h>
#include <blaze/math/shims/Log.h>
#include <blaze/math/shims/Log1p.h>
#include <blaze/math/shims/Log2.h>
#include <blaze/math/shims/Log10.h>
#include <blaze/math/shims/NextMultiple.h>
#include <blaze/math/shims/Pow.h>
#include <blaze/math/shims/Pow2.h>
#include <blaze/math/shims/Pow3.h>
#include <blaze/math/shims/Pow4.h>
#include <blaze/math/shims/PrevMultiple.h>
#include <blaze/math/shims/Qdrt.h>
#include <blaze/math/shims/Real.h>
#include <blaze/math/shims/Reset.h>
#include <blaze/math/shims/Round.h>
#include <blaze/math/shims/Serial.h>
#include <blaze/math/shims/Sign.h>
#include <blaze/math/shims/Sin.h>
#include <blaze/math/shims/Sinh.h>
#include <blaze/math/shims/Sqrt.h>
#include <blaze/math/shims/Tan.h>
#include <blaze/math/shims/Tanh.h>
#include <blaze/math/shims/Trunc.h>

#endif


text:
<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
<title>airbus_cobot_gui: __init__.py Source File</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
<link href="tabs.css" rel="stylesheet" type="text/css">

Main Page

Namespaces

Classes

Files

File List

src

airbus_cobot_gui

widget

widget/__init__.py

Go to the documentation of this file.

    1 ################################################################################

    2 #

    3 # Copyright Airbus Group SAS 2015

    4 # All rigths reserved.

    5 #

    6 # File Name : widget.py

    7 # Authors : Martin Matignon

    8 #

    9 # If you find any bug or if you have any question please contact

   10 # Adolfo Suarez Roos <adolfo.suarez@airbus.com>

   11 # Martin Matignon <martin.matignon.external@airbus.com>

   12 #

   13 #

   14 ################################################################################

airbus_cobot_gui

Author(s):

autogenerated on Thu Dec 17 2015 11:42:05


text:
package com.lotaris.rox.common.config;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.apache.commons.configuration.CompositeConfiguration;
import org.apache.commons.configuration.ConfigurationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Configuration for ROX clients. Define general configuration
 * that should be present for each run of a client.
 *
 * The configuration is not thread safe but it is not so critical.
 * Performance issues should be there.
 *
 * @author Laurent Prevost, laurent.prevost@lotaris.com
 */
public class Configuration {
	private static final Logger LOGGER = LoggerFactory.getLogger(Configuration.class);

	/**
	 * Default home directory
	 */
	private static final String DEFAULT_HOMEDIR = System.getProperty("user.home") + "/.rox";
	private static final String DEFAULT_CACHEDIR = DEFAULT_HOMEDIR + "/cache";

	/**
	 * Base configuration that should be present in the home directory
	 */
	private static final String BASE_CONFIG_PATH = ".rox/config.yml";

	/**
	 * Configuration placed in the classpath
	 */
	private static final String CLASSPATH_CONFIG = "rox.yml";

	/**
	 * The path to the UID directory into the home directory
	 */
	private static final String UID_DIRECTORY = "uid";

	/**
	 * Root node name of the tree configuration
	 */
	protected static final String P_ROOT_NODE_NAME = "rox";

	/**
	 * Parameter names
	 */
	private static final String P_ROX_WORKSPACE					= P_ROOT_NODE_NAME + ".workspace";
	private static final String P_ROX_SERVER					= P_ROOT_NODE_NAME + ".server";
	private static final String P_ROX_TAGS						= P_ROOT_NODE_NAME + ".tags";
	private static final String P_ROX_TICKETS					= P_ROOT_NODE_NAME + ".tickets";
	private static final String P_ROX_CATEGORY					= P_ROOT_NODE_NAME + ".category";
	private static final String P_ROX_GROUP						= P_ROOT_NODE_NAME + ".group";
	private static final String P_ROX_PUBLISH					= P_ROOT_NODE_NAME + ".publish";
	private static final String P_ROX_GENERATORSEED				= P_ROOT_NODE_NAME + ".seed";

	private static final String P_ROX_PAYLOAD_PRINT				= P_ROOT_NODE_NAME + ".payload.print";
	private static final String P_ROX_PAYLAOD_CACHE				= P_ROOT_NODE_NAME + ".payload.cache";
	private static final String P_ROX_PAYLOAD_SAVE				= P_ROOT_NODE_NAME + ".payload.save";

	private static final String P_ROX_OPTIMIZER_CLASS			= P_ROOT_NODE_NAME + ".java.optimizer.storeClass";
	private static final String P_ROX_OPTIMIZER_CACHE_DIR		= P_ROOT_NODE_NAME + ".java.optimizer.cacheDir";
	private static final String P_ROX_SERIALIZER_CLASS			= P_ROOT_NODE_NAME + ".java.serializerClass";

	private static final String P_PROJECT_API_ID				= P_ROOT_NODE_NAME + ".project.apiId";
	private static final String P_PROJECT_VERSION				= P_ROOT_NODE_NAME + ".project.version";
	private static final String P_PROJECT_CATEGORY				= P_ROOT_NODE_NAME + ".project.category";
	private static final String P_PROJECT_GROUP					= P_ROOT_NODE_NAME + ".project.group";
	private static final String P_PROJECT_TAGS					= P_ROOT_NODE_NAME + ".project.tags";
	private static final String P_PROJECT_TICKETS				= P_ROOT_NODE_NAME + ".project.tickets";
	private static final String P_PROJECT_GENERATORSEED			= P_ROOT_NODE_NAME + ".project.seed";

	/**
	 * Not thread safe, not critical
	 */
	private static Configuration instance;

	/**
	 * Configuration
	 */
	protected CompositeConfiguration config;

	/**
	 * Server list configuration.
	 */
	private ServerListConfiguration serverList;

	/**
	 * Local cache of tags and tickets
	 */
	private Set<String> tags;
	private Set<String> tickets;

	/**
	 * The path to uid directory
	 */
	private File uidDirectory;

	private boolean disabled = false;

	/**
	 * Constructor
	 */
	protected Configuration() {
		config = new CompositeConfiguration();
		serverList = new ServerListConfiguration();

		try {
			config.addConfiguration(new YamlConfigurationFile(CLASSPATH_CONFIG, P_ROOT_NODE_NAME, serverList));
		}
		catch (ConfigurationException ce) {

			if (LOGGER.isTraceEnabled()) {
				LOGGER.trace("Unable to load the project configuration.", ce);
			}
			else {
				LOGGER.warn("Unable to load the project configuration due to: {}", ce.getMessage());
			}
		}

		try {
			config.addConfiguration(new YamlConfigurationFile(BASE_CONFIG_PATH, P_ROOT_NODE_NAME, serverList));
		}
		catch (ConfigurationException ce) {
			if (LOGGER.isTraceEnabled()) {
				LOGGER.trace("Unable to load the ROX configuration.", ce);
			}
			else {
				LOGGER.warn("Unable to load the ROX configuration due to: {}", ce.getMessage());
			}
		}

		if (!serverList.isEmpty()) {
			LOGGER.debug(getServerListDescription());
		}

		final ServerConfiguration server = getInternalServerConfiguration();
		if (config.getNumberOfConfigurations() == 0) {
			disabled = true;
		} else if (serverList.isEmpty()) {
			disabled = true;
			LOGGER.warn("No server is defined in the ROX configuration files"
					+ "; define servers under the \"servers\" property.");
		} else if (server == null) {
			disabled = true;
			LOGGER.warn("No known server is selected in the ROX configuration files"
					+ "; set the \"server\" property to the name of one of the configured servers.");
		} else if (!server.isValid()) {
			disabled = true;
			LOGGER.warn("The selected server ({}) in the ROX configuration file is invalid", server.getName());
		}

		// Ensure there is the base path for UID directory
		uidDirectory = new File(getWorkspace(), UID_DIRECTORY);
		if (uidDirectory.exists() && uidDirectory.isFile()) {
			throw new IllegalArgumentException("The UID file in the ROX home directory is not a directory");
		}
		else if (!uidDirectory.exists()) {
			uidDirectory.mkdir();
		}
	}

	/**
	 * @return The configuration instance
	 */
	public static Configuration getInstance() {
		if (instance == null) {
			instance = new Configuration();
		}

		return instance;
	}

	/**
	 * Enforce the fact that a parameter is mandatory
	 * @param name The name of the parameter
	 * @return The value found
	 * @throws ConfigurationException When a mandatory parameter is missing
	 */
	private String getMandatory(String name) {
		if (!config.containsKey(name)) {
			throw new RoxConfigurationException(name + " parameter is missing.");
		}
		else {
			return config.getString(name);
		}

	}

	/**
	 * @return In case of missing mandatory configuration, ROX will be disabled to allow a smooth failure
	 */
	public boolean isDisabled() {
		return disabled;
	}

	/**
	 * @return The home directory where ROX client working files are stored
	 */
	public final String getWorkspace() {
		return config.getString(P_ROX_WORKSPACE, DEFAULT_HOMEDIR).replace("~",System.getProperty("user.home"));
	}

	/**
	 * @return Get the serializer class name to use when test results are serialized
	 */
	public String getSerializer() {
		return config.getString(P_ROX_SERIALIZER_CLASS);
	}

	public ServerConfiguration getServerConfiguration() {
		return getInternalServerConfiguration();
	}

	private ServerConfiguration getInternalServerConfiguration() {
		return serverList.get(config.getString(P_ROX_SERVER));
	}

	private String getServerListDescription() {

		final StringBuilder builder = new StringBuilder("ROX Center server list: ");
		for (final String serverName : serverList.getServerNames()) {

			if (builder.charAt(builder.length() - 1) != ' ') {
				builder.append(", ");
			}

			builder.append(serverName);

			if (!serverList.get(serverName).isValid()) {
				builder.append(" (INVALID)");
			} else if (serverName.equals(config.getString(P_ROX_SERVER))) {
				builder.append(" (selected)");
			}
		}

		return builder.toString();
	}

	/**
	 * @return the ROX API identifier of the project
	 * @throws ConfigurationException if no project API identifier is set in the configuration files
	 */
	public String getProjectApiId() {

		final ServerConfiguration server = getInternalServerConfiguration();
		if (server != null && server.getProjectApiId() != null) {
			return server.getProjectApiId();
		}

		final String globalProjectApiId = config.getString(P_PROJECT_API_ID);
		if (globalProjectApiId == null) {
			throw new RoxConfigurationException("ROX project API identifier is missing"
					+ "; set the project.apiId property"
					+ " or the projectApiId property of the selected server.");
		}

		return globalProjectApiId;
	}

	/**
	 * @return The project version
	 * @throws RuntimeException When there is no version configured
	 */
	public String getProjectVersion() {
		return getMandatory(P_PROJECT_VERSION);
	}

	/**
	 * @return The group (allow grouping multiple test runs in one group)
	 */
	public String getGroup() {
		if (config.containsKey(P_PROJECT_GROUP)) {
			return config.getString(P_PROJECT_GROUP);
		}

		return config.getString(P_ROX_GROUP);
	}

	/**
	 * @return The seed generator used in random generators
	 */
	public Long getGeneratorSeed() {
		if (config.containsKey(P_PROJECT_GENERATORSEED)) {
			return config.getLong(P_PROJECT_GENERATORSEED, null);
		}

		return config.getLong(P_ROX_GENERATORSEED, null);
	}

	/**
	 * @return By default, optimization will be done
	 */
	public boolean isPayloadCache() {
		return config.getBoolean(P_ROX_PAYLAOD_CACHE, Boolean.TRUE);
	}

	/**
	 * @return By default, no print will be done
	 */
	public boolean isPayloadPrint() {
		return config.getBoolean(P_ROX_PAYLOAD_PRINT, Boolean.FALSE);
	}

	/**
	 * @return The class name to use for the optimization process
	 */
	public String getOptimizerStoreClass() {
		return config.getString(P_ROX_OPTIMIZER_CLASS);
	}

	/**
	 * @return The caching directory where to store cached data
	 */
	public String getOptimizerCacheDir() {
		return config.getString(P_ROX_OPTIMIZER_CACHE_DIR, DEFAULT_CACHEDIR).replace("~", System.getProperty("user.home"));
	}

	/**
	 * @return Get tags from the configuration, if none, empty set is returned
	 */
	@SuppressWarnings("unchecked")
	public Set<String> getTags() {
		if (tags == null) {
			tags = new HashSet<>();

			List<String> globalTags = (List<String>) config.getProperty(P_ROX_TAGS);
			if (globalTags != null && !globalTags.isEmpty()) {
				tags.addAll(globalTags);
			}

			List<String> projectTags = (List<String>) config.getProperty(P_PROJECT_TAGS);
			if (projectTags != null && !projectTags.isEmpty()) {
				tags.addAll(projectTags);
			}
		}

		return tags;
	}

	/**
	 * @return Get ticket from the configuration, if none, empty set is returned
	 */
	@SuppressWarnings("unchecked")
	public Set<String> getTickets() {
		if (tickets == null) {
			tickets = new HashSet<>();

			List<String> globalTickets = (List<String>) config.getProperty(P_ROX_TICKETS);
			if (globalTickets != null && !globalTickets.isEmpty()) {
				tickets.addAll(globalTickets);
			}

			List<String> projectTickets = (List<String>) config.getProperty(P_PROJECT_TICKETS);
			if (projectTickets != null && !projectTickets.isEmpty()) {
				tickets.addAll(projectTickets);
			}
		}

		return tickets;
	}

	/**
	 * @return The category of the tests
	 */
	public String getCategory() {
		if (config.containsKey(P_PROJECT_CATEGORY)) {
			return config.getString(P_PROJECT_CATEGORY);
		}

		return config.getString(P_ROX_CATEGORY);
	}

	/**
	 * @return Define if the results must be stored or not locally
	 */
	public boolean isSave() {
		return config.getBoolean(P_ROX_PAYLOAD_SAVE, Boolean.FALSE);
	}

	/**
	 * @return Define if the test results must be send to ROX Server
	 */
	public boolean isPublish() {
		return config.getBoolean(P_ROX_PUBLISH, Boolean.TRUE);
	}

	/**
	 * Shortcut method to {@link Configuration#getUid(java.lang.String, java.lang.String, java.lang.String, boolean) }
	 *
	 * @param category The category
	 * @param projectName The project name
	 * @param projectVersion The project version
	 * @return The UID generated
	 */
	public String getUid(String category, String projectName, String projectVersion) {
		return getUid(category, projectName, projectVersion, false);
	}

	/**
	 * Generate a UID or retrieve the latest if it is valid depending the context given
	 * by the category, project name and project version
	 *
	 * @param category The category
	 * @param projectName The project name
	 * @param projectVersion The project version
	 * @param force Force the generation of a new UID
	 * @return The valid UID
	 */
	public String getUid(String category, String projectName, String projectVersion, boolean force) {
		String uid = null;

		if (!force) {
			uid = readUid(new File(uidDirectory, "latest"));
		}

		// Check if the UID was already used for the ROX client and projec/version
		if (uid != null && uidAlreadyUsed(category, projectName, uid)) {
			uid = null;
		}

		// Generate UID and store it
		if (uid == null) {
			uid = generateUid();
			writeUid(new File(uidDirectory, "latest"), uid);
		}

		writeUid(getUidFile(category, projectName, projectVersion), uid);

		return uid;
	}

	/**
	 * @return The last UID generated, null if none is available
	 */
	public String retrieveLastUid() {
		return readUid(new File(uidDirectory, "latest"));
	}

	/**
	 * @return Generate a UID
	 */
	private String generateUid() {
		return UUID.randomUUID().toString();
	}

	/**
	 * Read a UID file
	 *
	 * @param uidFile The UID file to read
	 * @return The UID read
	 */
	private String readUid(File uidFile) {
		String uid = null;

		// Try to read the shared UID
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(uidFile));

			String line;
			while ((line = br.readLine()) != null) {
				uid = line;
			}
		}
		catch (IOException ioe) {}
		finally { if (br != null) { try { br.close(); } catch (IOException ioe) {} } }

		return uid;
	}

	/**
	 * Write a UID file
	 * @param uidFile The UID file to write
	 * @param uid The UID to write to the file
	 */
	private void writeUid(File uidFile, String uid) {
		BufferedWriter bw = null;
		try {
			bw = new BufferedWriter(new FileWriter(uidFile));
			bw.write(uid);
		}
		catch (IOException ioe) {}
		finally { if (bw != null) { try { bw.close(); } catch (IOException ioe) {} } }
	}

	/**
	 * Check if a UID was already used in any context
	 *
	 * @param category The category to check
	 * @param projectName The project name to check
	 * @param uid The UID to validate
	 * @return True if the UID is present for at least one version of a project in a category, false otherwise
	 */
	private boolean uidAlreadyUsed(String category, String projectName, String uid) {
		if (uid == null) {
			return false;
		}

		else {
			for (File versionDirectory : getUidFilesForProject(category, projectName)) {
				String uidRead = readUid(new File(versionDirectory, "latest"));

				if (uidRead != null && !uidRead.isEmpty()) {
					if (uidRead.equals(uid)) {
						return true;
					}
				}
			}

			return false;
		}
	}

	/**
	 * Retrieve the list of the version directories for the project
	 *
	 * @param category The category
	 * @param projectName The project name
	 * @return The list of version directories or empty list if none are present
	 */
	private List<File> getUidFilesForProject(String category, String projectName) {
		// Check that the category directory exists
		File categoryDirectory = new File(uidDirectory, category);
		if (!categoryDirectory.exists() || (categoryDirectory.exists() && categoryDirectory.isFile())) {
			return new ArrayList<>();
		}

		// Check that the project directory exists
		File projectDirectory = new File(categoryDirectory, projectName);
		if (!projectDirectory.exists() || (projectDirectory.exists() && projectDirectory.isFile())) {
			return new ArrayList<>();
		}

		// Get all the version directories
		List<File> versionDirectories = new ArrayList<>();
		for (File electableDirectory : projectDirectory.listFiles()) {
			if (electableDirectory.isDirectory()) {
				versionDirectories.add(electableDirectory);
			}
		}

		return versionDirectories;
	}

	/**
	 * Get the UID file regarding the category, project name and project version
	 *
	 * @param category The category
	 * @param projectName The project name
	 * @param projectVersion The project version
	 * @return The UID file
	 */
	private File getUidFile(String category, String projectName, String projectVersion) {
		// Check that the category directory exists
		File categoryDirectory = new File(uidDirectory, category);
		if (categoryDirectory.exists() && categoryDirectory.isFile()) {
			throw new IllegalArgumentException("The category file for the UID storage is not a directory");
		}
		else if (!categoryDirectory.exists()) {
			categoryDirectory.mkdir();
		}

		// Check that the project directory exists
		File projectDirectory = new File(categoryDirectory, projectName);
		if (projectDirectory.exists() && projectDirectory.isFile()) {
			throw new IllegalArgumentException("The project file for the UID store is not a directory");
		}
		else if (!projectDirectory.exists()) {
			projectDirectory.mkdir();
		}

		// Check that the version directory exists
		File versionDirectory = new File(projectDirectory, projectVersion);
		if (versionDirectory.exists() && versionDirectory.isFile()) {
			throw new IllegalArgumentException("The version file for the UID store is not a directory");
		}
		else if (!versionDirectory.exists()) {
			versionDirectory.mkdir();
		}

		return new File(versionDirectory, "latest");
	}
}


text:
package de.hannesstruss.windfish.library;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;

class EmptyActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
  @Override public void onActivityCreated(Activity activity, Bundle bundle) {
  }

  @Override public void onActivityStarted(Activity activity) {
  }

  @Override public void onActivityResumed(Activity activity) {
  }

  @Override public void onActivityPaused(Activity activity) {
  }

  @Override public void onActivityStopped(Activity activity) {
  }

  @Override public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
  }

  @Override public void onActivityDestroyed(Activity activity) {
  }
}


text:
module VersionHelpers
  module_function

  def major_version_of(mod)
    Gem::Version.new(mod::VERSION).segments.first
  end
end


text:
#ifndef REALCONS_CONSOLE_PDP8I_H_
#define REALCONS_CONSOLE_PDP8I_H_

#include "realcons.h"

// Signals set in the combinated instruction_decode word from cpu
#define REALCONS_PDP8I_INSTRUCTION_DECODE_AND	0x01
#define REALCONS_PDP8I_INSTRUCTION_DECODE_TAD	0x02
#define REALCONS_PDP8I_INSTRUCTION_DECODE_ISZ	0x04
#define REALCONS_PDP8I_INSTRUCTION_DECODE_DCA	0x08
#define REALCONS_PDP8I_INSTRUCTION_DECODE_JMS	0x10
#define REALCONS_PDP8I_INSTRUCTION_DECODE_JMP	0x20
#define REALCONS_PDP8I_INSTRUCTION_DECODE_IOT	0x40
#define REALCONS_PDP8I_INSTRUCTION_DECODE_OPR	0x80

// Signals set for the major state indicator of an instruction
// "One of these indicates that the processor is currently performing or
// has performed a certain cycle."
#define REALCONS_PDP8I_MAJORSTATE_FETCH			0x01
#define REALCONS_PDP8I_MAJORSTATE_EXECUTE		0x02
#define REALCONS_PDP8I_MAJORSTATE_DEFER			0x04
#define REALCONS_PDP8I_MAJORSTATE_WORDCOUNT		0x08
#define REALCONS_PDP8I_MAJORSTATE_CURRENTADDRESS 0x10
#define REALCONS_PDP8I_MAJORSTATE_BREAK			0x20

// Signals set by miscellaneous flip flops
// Ion indicates the 1 status of the INT.ENABLE flip - flop.
//		When lit, the interrupt control is enabled for
//		information exchange with an I / O device.
// Pause indicates the 1 status of the PAUSE flip - flop when lit.
//		The PAUSE flip - flop is set for 2.75 micro secs by any IOT
//		instruction that requires generation of IOP pulses or by
//		any EAE instruction that require shifting of information.
// Run	indicates the 1 status of the RUN flip - flop. When lit,
//      the internal timing circuits are enabled and the machine
//		performs instructions.
#define REALCONS_PDP8I_FLIPFLOP_ION				0x01
#define REALCONS_PDP8I_FLIPFLOP_PAUSE			0x02
#define REALCONS_PDP8I_FLIPFLOP_RUN				0x04 // not used, sim_is_running

typedef struct
{
	/* base class members, identical for all panels */
	struct realcons_struct *realcons; // parent
	// parant is used to link to other data structs:
	//  example: Blinkenlight API panel struct = realcons->blinkenlight_panel

	/* Signals for SimH's generic console interface
	 * (halt, start, singlestep, exam deposit).
	 * Signals in VHDL are variables holding values of physical wires
	 * Signals in REALCONS are pointers to variables either in the SimH simulation code, or
	 * in panel logic. They connect simulation and panel. A certain signal is can be unidirectional
	 * (either set by simulator and read by panel logic, ore vice verse) or be bidirectional.
	 */
	t_addr *cpusignal_memory_address_phys_register; // address of last bus cycle (EXAM/DEPOSIT)
	char **cpusignal_register_name; // name of last accessed exam/deposit register
	t_value *cpusignal_memory_data_register; // data of last bus cycle
	int *cpusignal_console_halt; // 1, if a real console halts program execution
	volatile t_bool *cpusignal_run; // 1, if simulated cpu is running

	/* Signals for SimH's PDP8 cpu. */
	t_value *cpusignal_switch_register;
	int32 *cpusignal_if_pc; // IF'PC, 15bit PC. IF= instruction field
	int32	*cpusignal_df; // DF = data field
	int32 	*cpusignal_link_accumulator ;
	int32 	*cpusignal_multiplier_quotient ;
	int32 	*cpusignal_step_counter;

	int32	*cpusignal_instruction_decode; // bit mask for decoded isntruction, see REALCONS_PDP8I_INSTRUCTION_DECODE_*
	int32	*cpusignal_majorstate_curinstr; // sum of all states in curent instruction
	int32	*cpusignal_majorstate_last; // last state cpu was in (use after single step)

	int32	*cpusignal_flipflops; // see REALCONS_PDP8I_FLIPFLOPS_*

	// see  ...\projects\11pidp8\src\
    // input controls on the panel
    blinkenlight_control_t *keyswitch_power;
    blinkenlight_control_t *keyswitch_panel_lock;

	blinkenlight_control_t *switch_start;
	blinkenlight_control_t *switch_load_address;
	blinkenlight_control_t *switch_deposit;
	blinkenlight_control_t *switch_examine;
	blinkenlight_control_t *switch_continue;
	blinkenlight_control_t *switch_stop;
	blinkenlight_control_t *switch_single_step;
	blinkenlight_control_t *switch_single_instruction;
	blinkenlight_control_t *switch_switch_register;
	blinkenlight_control_t *switch_data_field;
	blinkenlight_control_t *switch_instruction_field;

	// output controls on the panel
	blinkenlight_control_t *led_program_counter;
	blinkenlight_control_t *led_inst_field;
	blinkenlight_control_t *led_data_field;
	blinkenlight_control_t *led_memory_address;
	blinkenlight_control_t *led_memory_buffer;
	blinkenlight_control_t *led_accumulator;
	blinkenlight_control_t *led_link;
	blinkenlight_control_t *led_multiplier_quotient;
	blinkenlight_control_t *led_and;
	blinkenlight_control_t *led_tad;
	blinkenlight_control_t *led_isz;
	blinkenlight_control_t *led_dca;
	blinkenlight_control_t *led_jms;
	blinkenlight_control_t *led_jmp;
	blinkenlight_control_t *led_iot;
	blinkenlight_control_t *led_opr;
	blinkenlight_control_t *led_fetch;
	blinkenlight_control_t *led_execute;
	blinkenlight_control_t *led_defer;
	blinkenlight_control_t *led_word_count;
	blinkenlight_control_t *led_current_address;
	blinkenlight_control_t *led_break;
	blinkenlight_control_t *led_ion;
	blinkenlight_control_t *led_pause;
	blinkenlight_control_t *led_run;
	blinkenlight_control_t *led_step_counter;

	// intern state registers of console panel
	unsigned run_state; // cpu can be: reset, halt, running.

} realcons_console_logic_pdp8i_t;

realcons_console_logic_pdp8i_t *realcons_console_pdp8i_constructor(
struct realcons_struct *realcons);
void realcons_console_pdp8i_destructor(realcons_console_logic_pdp8i_t *_this);

struct realcons_console_controller_interface_struct;
void realcons_console_pdp8i_interface_connect(realcons_console_logic_pdp8i_t *_this,
struct realcons_console_controller_interface_struct *intf, char *panel_name);

int realcons_console_pdp8i_test(realcons_console_logic_pdp8i_t *_this, int arg);

// process panel state. operates only "panel" data struct
t_stat realcons_console_pdp8i_service(realcons_console_logic_pdp8i_t *_this);
t_stat realcons_console_pdp8i_reset(realcons_console_logic_pdp8i_t *_this);

#endif /* REALCONS_CONSOLE_PDP8I_H_ */