public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable<MatcherWithAction> matchersWithActions)
        {
            loggerService.AssertNotNull(nameof(loggerService));
            speechService.AssertNotNull(nameof(speechService));
            name.AssertNotNull(nameof(name));
            matchersWithActions.AssertNotNull(nameof(matchersWithActions));

            if (setCount < 0)
            {
                throw new ArgumentException("setCount cannot be less than zero.", "setCount");
            }

            if (repetitionCount < 0)
            {
                throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount");
            }

            this.logger = loggerService.GetLogger(this.GetType());
            this.speechService = speechService;
            this.name = name;
            this.setCount = setCount;
            this.repetitionCount = repetitionCount;
            this.matchersWithActions = matchersWithActions.ToImmutableList();

            using (var dummyExecutionContext = new ExecutionContext())
            {
                this.duration = this
                    .GetEventsWithActions(dummyExecutionContext)
                    .SelectMany(x => x.Actions)
                    .Select(x => x.Duration)
                    .DefaultIfEmpty()
                    .Aggregate((running, next) => running + next);
            }
        }
Example #2
0
        /// <summary>
        /// Asynchronously writes a record to this <c>CsvWriter</c>.
        /// </summary>
        /// <remarks>
        /// None of the <see cref="System.String"/>s within <paramref name="values"/> can be <see langword="null"/>. If so, an exception will be thrown.
        /// </remarks>
        /// <param name="values">
        /// The values comprising the record.
        /// </param>
        /// <returns>
        /// A <see cref="Task"/> representing the asynchronous operation.
        /// </returns>
        public async Task WriteRecordAsync(IEnumerable<string> values)
        {
            Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty.");

            this.EnsureNotDisposed();
            values.AssertNotNull("values");
            this.WriteRecordToBuffer(values);
            await this.FlushBufferToTextWriterAsync().ConfigureAwait(false);
        }
        public MetronomeAction(IAudioService audioService, IDelayService delayService, ILoggerService loggerService, IEnumerable<MetronomeTick> ticks)
        {
            audioService.AssertNotNull(nameof(audioService));
            delayService.AssertNotNull(nameof(delayService));
            loggerService.AssertNotNull(nameof(loggerService));
            ticks.AssertNotNull(nameof(ticks));

            this.ticks = ticks.ToImmutableList();
            this.innerAction = new SequenceAction(GetInnerActions(audioService, delayService, loggerService, this.ticks));
        }
Example #4
0
        /// <summary>
        /// Creates a new NetNode with the specified fields.
        /// </summary>
        /// <param name="guid">The unique Id for the computer.</param>
        /// <param name="name">The user friendly name for the computer.</param>
        /// <param name="uri">The computer's Uri, if it has one.</param>
        /// <param name="edges">Edges from this computer to others.</param>
        public NetNode(Guid guid, string name, Uri uri, IEnumerable<INetEdge> edges)
        {
            guid.AssertNotNull(nameof(guid));
            name.AssertNotNullOrEmptyOrWhitespace(nameof(name));
            edges.AssertNotNull(nameof(edges));

            this.guid = guid;
            this.name = name;
            this.edges = edges.ToImmutableDictionary(edge => edge.Destination.Guid, edge => edge);
        }
        public SequenceAction(IEnumerable<IAction> children)
        {
            children.AssertNotNull(nameof(children), assertContentsNotNull: true);

            this.children = children.ToImmutableList();
            this.duration = this
                .children
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Aggregate((running, next) => running + next);
        }
        public ParallelAction(IEnumerable<IAction> children)
        {
            children.AssertNotNull(nameof(children), assertContentsNotNull: true);

            this.children = children.ToImmutableList();
            this.duration = this
                .children
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Max();
        }
Example #7
0
        /// <summary>
        /// Creates a new NetGraph representation from raw data.
        /// </summary>
        /// <param name="nodes">
        /// A list of all nodes. The first node is assumed to be this computer.
        /// </param>
        private NetGraph(IEnumerable<INetNode> nodes)
        {
            nodes.AssertNotNull(nameof(nodes));

            if (nodes.FirstOrDefault() != null)
            {
                this.thisNode = nodes.First();
            }

            this.nodes = nodes.ToImmutableDictionary(edge => edge.Guid, edge => edge);
        }
Example #8
0
        public IRace Create(IDistanceCalculator distanceCalculator, IEnumerable<Waypoint> waypoints)
        {
          
                distanceCalculator.AssertNotNull();
                waypoints = waypoints as List<Waypoint> ?? waypoints.ToList();
                waypoints.AssertNotEmpty();
                waypoints.AssertNotNull();

                var Race = new RaceService(distanceCalculator, waypoints);
                return Race;
  
            
        }
        /// <summary>
        /// Determines whether the principal contains the specified claim types.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claimTypes">The claim types.</param>
        /// <returns>
        /// <c>true</c> if the principal contains the specified claim types; otherwise, <c>false</c>.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="claimTypes"/> is <see langword="null"/>.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// One of the items in the <paramref name="claimTypes"/> collection is <see langword="null"/>.
        /// </exception>
        public static bool HasClaimTypes(this ClaimsPrincipal principal, IEnumerable<string> claimTypes)
        {
            claimTypes.AssertNotNull(true, "claimTypes");

            foreach (var type in claimTypes)
            {
                if (!principal.HasClaim(c => c.Type == type))
                {
                    return false;
                }
            }

            return true;
        }
Example #10
0
        /// <summary>
        /// Determines whether the principal contains the specified claims.
        /// </summary>
        /// <param name="principal">The principal.</param>
        /// <param name="claims">The claims.</param>
        /// <returns><c>true</c> if the principal contains the specified claims; otherwise, <c>false</c>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="claims"/> is <see langword="null"/>.</exception>
        /// <exception cref="ArgumentException">
        /// One of the items in the <paramref name="claims"/> collection is <see langword="null"/>.
        /// </exception>
        public static bool HasClaims(this ClaimsPrincipal principal, IEnumerable<Claim> claims)
        {
            claims.AssertNotNull(true, "claims");

            foreach (var claim in claims)
            {
                if (!principal.HasClaim(claim.Type, claim.Value))
                {
                    return false;
                }
            }

            return true;
        }
        public ExerciseProgram(ILoggerService loggerService, string name, IEnumerable<Exercise> exercises)
        {
            loggerService.AssertNotNull(nameof(loggerService));
            name.AssertNotNull(nameof(name));
            exercises.AssertNotNull(nameof(exercises), assertContentsNotNull: true);

            this.logger = loggerService.GetLogger(this.GetType());
            this.name = name;
            this.exercises = exercises.ToImmutableList();
            this.duration = this
                .exercises
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Aggregate((running, next) => running + next);
        }
Example #12
0
        /// <summary>
        /// Writes a record to this <c>CsvWriter</c>.
        /// </summary>
        /// <remarks>
        /// Any <see langword="null"/> values will be written as empty strings.
        /// </remarks>
        /// <param name="values">
        /// The values comprising the record.
        /// </param>
        public void WriteRecord(IEnumerable<string> values)
        {
            Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty.");

            this.EnsureNotDisposed();
            values.AssertNotNull("values");
            this.WriteRecordToBuffer(values);
            this.FlushBufferToTextWriter();
        }
Example #13
0
        /// <summary>
        /// Initializes a new instance of the HeaderRecord class.
        /// </summary>
        /// <param name="columnNames">
        /// The names of the columns in the header record.
        /// </param>
        /// <param name="readOnly">
        /// <see langword="true"/> if the header record is read-only, otherwise <see langword="false"/>.
        /// </param>
        public HeaderRecord(bool readOnly, IEnumerable<string> columnNames)
            : base(readOnly, columnNames)
        {
            columnNames.AssertNotNull("columnNames", true);

            this.columnNameToIndexMap = new Dictionary<string, int>();
            this.PopulateColumnNameToIndexMap(0, true);

            if (readOnly)
            {
                this.columnNameToIndexMap = new ReadOnlyDictionary<string, int>(this.columnNameToIndexMap);
            }
        }
 public ExercisePrograms(IEnumerable<ExerciseProgram> programs)
 {
     programs.AssertNotNull(nameof(programs), assertContentsNotNull: true);
     this.programs = programs.ToImmutableList();
 }
 public JsonSyntaxNode(IEnumerable<JsonSyntaxNode> children)
 {
     children.AssertNotNull();
     this.children = new ReadOnlyCollection<JsonSyntaxNode>(children.ToList());
 }