private string GetReleaseAbbr(ReleaseState state) { switch (state) { case ReleaseState.PreAlpha: return("pa"); case ReleaseState.Alpha: return("a"); case ReleaseState.PreBeta: return("pb"); case ReleaseState.Beta: return("b"); case ReleaseState.ReleaseCandidate: return("rc"); case ReleaseState.Release: return("r"); default: throw new ArgumentException("Invalid release state."); } }
internal ElasticsearchVersion(string version, string zip, ReleaseState state, string localFolder) : base(version) { this.Version = version; this.ReleaseState = state; this.Zip = zip; this.ExtractFolderName = localFolder; this.DownloadLocations = new ElasticsearchDownloadLocations(this); }
internal static void AddOrUpdate(ReleaseState release) { AddOrUpdate(Releases, release); if (release.Subscription != null && release.IsPublished) { AddOrUpdate(PublishedReleases, release); } }
public static BitmapImage GetCoverOverlay(ReleaseState state) { if (state == ReleaseState.Release) { return(null); } return(new BitmapImage(new Uri($"pack://application:,,,/{typeof(ResourcesHelper).Assembly.GetName().Name};component/Resources/{state.ToString()}.png"))); }
private bool OnSubscriptionCreate(SubscriptionCreateCommand command) { if (!IsSubscriptionValid(command) || _state.Subscription != null) { return(false); } PersistAsync(command, cmd => { _state = _state.AddSubscription(Guid.NewGuid().ToString(), command); TellStateUpdated(); }); return(true); }
private bool OnSubscriptionReplace(SubscriptionReplaceCommand command) { if (!IsSubscriptionValid(command)) { return(false); } PersistAsync(command, cmd => { _state = _state.ReplaceSubscription(command); TellStateUpdated(); }); return(true); }
private bool OnMetadataUpdated(MetadataUpdateCommand command) { if (!CommandValidator.Validate(command).Success || command.ReleaseId != PersistenceId || !_state.TrackList.ContainsKey(command.TrackId) || command.Timestamp <= _state.TrackList[command.TrackId].Timestamp) { return(false); } Persist(command, cmd => { _state = _state.UpdateMetadata(cmd); TellStateUpdated(); }); return(true); }
public void Store(ReleaseState state) { var entity = new Entity { Key = ReleaseKeyFactory.CreateKey(state.ReleaseId), [nameof(ReleaseState.Artist)] = state.Artist, [nameof(ReleaseState.Title)] = state.Title, [nameof(ReleaseState.Genre)] = state.Genre, [nameof(ReleaseState.OwnerId)] = state.OwnerId.ToString(), [nameof(ReleaseState.Cover)] = state.Cover, [nameof(ReleaseState.TrackList)] = state.TrackList.Select(t => ToEntity(t.Value)).ToArray(), [nameof(ReleaseState.Subscription)] = ToEntity(state.Subscription), [nameof(ReleaseState.Timestamp)] = state.Timestamp, }; Database.Upsert(entity); }
public void SwitchState(HandGesture inputType) { BaseInputState state = null; switch (inputType) { case HandGesture.Touching: state = new TouchingState(m_InputTouch); break; case HandGesture.Click: state = new ClickState(m_InputTouch); break; case HandGesture.Holding: state = new HoldingState(m_InputTouch); break; case HandGesture.Drag: state = new DragState(m_InputTouch); break; case HandGesture.Slip: state = new SlipState(m_InputTouch); break; case HandGesture.Realease: state = new ReleaseState(m_InputTouch); break; default: state = new NoneInput(m_InputTouch); break; } if (state != null) { Switch(state); } else { Debug.Log("InputStateFSM.SwitchState " + inputType + "is None"); } }
private void ReleaseQuery(ThreadQueue.TaskControl control, object state) { try { if (db != null) { ReleaseState rlState = state as ReleaseState; rlState.Query.Release(); } else { throw new Exception("Database not ready!"); } } catch (Exception ex) { Debug.LogError("SQLiteAsync : Exception : " + ex.Message); } }
public ReleaseActor(ReleaseState state, ImmutableHashSet <string> exitstingTrackIds, ActorPath readStorageUpdateActor) { _readStorageUpdateActor = readStorageUpdateActor; Command <ReleaseUpdateCommand>(msg => HandleUpdateMessage(msg)); Command <TrackListUpdated>(msg => OnTrackListUpdated(msg)); Command <MetadataCreateCommand>(m => HandleMetadataAdded(m)); Command <MetadataUpdateCommand>(m => OnMetadataUpdated(m)); Command <SubscriptionCreateCommand>(c => OnSubscriptionCreate(c)); Command <SubscriptionReplaceCommand>(c => OnSubscriptionReplace(c)); Recover <ReleaseUpdateCommand>(msg => HandleUpdateMessage(msg)); Recover <TrackListUpdated>(msg => OnTrackListUpdated(msg)); Recover <MetadataCreateCommand>(m => HandleMetadataAdded(m)); Recover <MetadataUpdateCommand>(m => OnMetadataUpdated(m)); Recover <SubscriptionCreateCommand>(c => OnSubscriptionCreate(c)); Recover <SubscriptionReplaceCommand>(c => OnSubscriptionReplace(c)); _state = state; TrackIds = exitstingTrackIds; TellStateUpdated(); }
// Update is called once per frame void Update () { switch( m_State ) { case ReleaseState.Ready : m_State = ReleaseState.Fire ; break ; case ReleaseState.Fire : InstantiateMissle() ; m_State = ReleaseState.Reload ; m_FireTime = Time.timeSinceLevelLoad ; break ; case ReleaseState.Reload : if( Time.timeSinceLevelLoad > m_FireTime + m_ReloadSec ) { m_State = ReleaseState.Ready ; } break ; } }
public BaseItemDefinition( string metadataId, string name, ItemClass itemClass, IEnumerable <string> rawTags, Tags tags, IReadOnlyList <Property> properties, IReadOnlyList <UntranslatedStat> buffStats, Requirements requirements, IReadOnlyList <CraftableStat> implicitModifiers, int inventoryHeight, int inventoryWidth, int dropLevel, ReleaseState releaseState, string visualIdentity) { MetadataId = metadataId; Name = name; ItemClass = itemClass; RawTags = rawTags; Tags = tags; Properties = properties; BuffStats = buffStats; Requirements = requirements; ImplicitModifiers = implicitModifiers; InventoryHeight = inventoryHeight; InventoryWidth = inventoryWidth; DropLevel = dropLevel; ReleaseState = releaseState; VisualIdentity = visualIdentity; }
// Update is called once per frame void Update() { switch (m_State) { case ReleaseState.Ready: m_State = ReleaseState.Fire; break; case ReleaseState.Fire: InstantiateMissle(); m_State = ReleaseState.Reload; m_FireTime = Time.timeSinceLevelLoad; break; case ReleaseState.Reload: if (Time.timeSinceLevelLoad > m_FireTime + m_ReloadSec) { m_State = ReleaseState.Ready; } break; } }
private bool HandleMetadataAdded(MetadataCreateCommand command) { if (!IsMetadataAddValid(command)) { return(false); } var evt = new MetadataCreated { TrackId = command.TrackId, Album = command.Album, Artist = command.Artist, Genre = command.Genre, Timestamp = command.Timestamp, Title = command.Title }; Persist(evt, e => { _state = _state.AddMetadata(command); TellStateUpdated(); }); return(true); }
public SkillBaseItemDefinition( string displayName, string metadataId, ReleaseState releaseState, IEnumerable <string> gemTags) => (DisplayName, MetadataId, ReleaseState, GemTags) = (displayName, metadataId, releaseState, gemTags);
public void OnReleaseStateChange(ReleaseState state) { InMemoryAppState.AddOrUpdate(state); _releaseProvider.Store(state); }
private static void AddOrUpdate(ConcurrentDictionary <string, ReleaseState> storage, ReleaseState release) { if (storage.ContainsKey(release.ReleaseId)) { storage[release.ReleaseId] = release; } else { storage.TryAdd(release.ReleaseId, release); } }
private void UpdateState(ReleaseUpdateCommand command) { _state = _state.Update(command); }
private void ReleaseQueryComplete(object state) { ReleaseState rlState = state as ReleaseState; rlState.Callback(rlState.State); }
public SkillBaseItemDefinition( string displayName, string metadataId, ReleaseState releaseState, IReadOnlyCollection <string> gemTags) => (DisplayName, MetadataId, ReleaseState, GemTags) = (displayName, metadataId, releaseState, gemTags);
private IActorRef PlaceChildActor(ReleaseState state) { return(Context.ActorOf(Props.Create(() => new ReleaseActor(state, ExistingTrackIds, _readStorageUpdateActor)), state.ReleaseId)); }
internal void setState(ReleaseState state) { this.m_releaseStates = state; }