/// <summary>
/// Initializes a new instance of the <see cref="ResourcePreparationTaskAndValidity"/> struct.
/// </summary>
internal ResourcePreparationTaskAndValidity(Task preparationTask, ResourceState finalState)
: this()
{
Requires.NotNull(preparationTask, nameof(preparationTask));
this.PreparationTask = preparationTask;
this.State = finalState;
}
/// <summary>
/// Wait for a resource to reach the specified state.
/// </summary>
/// <typeparam name="TResource">
/// The resource type.
/// </typeparam>
/// <param name="resourceId">
/// The resource Id.
/// </param>
/// <param name="targetState">
/// The resource state to wait for.
/// </param>
/// <param name="timeout">
/// The amount of time to wait for the resource to reach the target state.
/// </param>
/// <param name="cancellationToken">
/// An optional cancellation token that can be used to cancel the request.
/// </param>
/// <returns>
/// The resource (or <c>null</c> if the resource has been deleted).
/// </returns>
/// <exception cref="TimeoutException">
/// The timeout period elapsed before the resource reached the target state.
/// </exception>
/// <exception cref="CloudControlException">
/// The target resource was not found with the specified Id, and <paramref name="targetState"/> is not <see cref="ResourceState.Deleted"/>
/// </exception>
public async Task <TResource> WaitForState <TResource>(Guid resourceId, ResourceState targetState, TimeSpan timeout, CancellationToken cancellationToken = default(CancellationToken))
where TResource : Resource
{
Stopwatch stopwatch = Stopwatch.StartNew();
Func <Guid, CancellationToken, Task <Resource> > loader = CreateResourceLoader <TResource>();
Resource resource = await loader(resourceId, cancellationToken);
while (resource != null && resource.State != targetState)
{
if (stopwatch.Elapsed > timeout)
{
throw new TimeoutException($"Timed out after waiting {timeout.TotalSeconds} seconds for {typeof(TResource).Name} '{resourceId}' to reach state '{targetState}'.");
}
resource = await loader(resourceId, cancellationToken);
}
if (resource == null && targetState != ResourceState.Deleted)
{
throw new CloudControlException($"{typeof(TResource).Name} not found with Id '{resourceId}'.");
}
return((TResource)resource);
}
public Signal(string name) : base(name, ResourceType.Signal)
{
Name = name;
ResouceType = ResourceType.Signal;
ResourceStates = new ResourceState();
ResourceStates.SetState("SensorIsSet", false);
}
/// <summary>
/// Returns true if MetaClub instances are equal
/// </summary>
/// <param name="other">Instance of MetaClub to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(MetaClub other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Id == other.Id ||
Id != null &&
Id.Equals(other.Id)
) &&
(
ResourceState == other.ResourceState ||
ResourceState != null &&
ResourceState.Equals(other.ResourceState)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
));
}
private void btnSend_Click(object sender, EventArgs e)
{
CFXEnvelope msg;
if (currentState == ResourceState.Off)
{
msg = new CFXEnvelope(new StationStateChanged()
{
NewState = ResourceState.On,
OldState = currentState,
OldStateDuration = DateTime.Now - lastStateChange,
});
}
else
{
msg = new CFXEnvelope(new StationStateChanged()
{
NewState = ResourceState.Off,
OldState = currentState,
OldStateDuration = DateTime.Now - lastStateChange,
});
}
lastStateChange = msg.TimeStamp;
currentState = (msg.MessageBody as StationStateChanged).NewState;
theEndpoint.Publish(msg);
}
public virtual void Handle(ResourceEvent @event)
{
try
{
this.writeLock.Lock();
Path resourcePath = @event.GetLocalResourceRequest().GetPath();
Log.Debug("Processing " + resourcePath + " of type " + @event.GetType());
ResourceState oldState = this.stateMachine.GetCurrentState();
ResourceState newState = null;
try
{
newState = this.stateMachine.DoTransition(@event.GetType(), @event);
}
catch (InvalidStateTransitonException e)
{
Log.Warn("Can't handle this event at current state", e);
}
if (oldState != newState)
{
Log.Info("Resource " + resourcePath + (localPath != null ? "(->" + localPath + ")"
: string.Empty) + " transitioned from " + oldState + " to " + newState);
}
}
finally
{
this.writeLock.Unlock();
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Id != null)
{
hashCode = hashCode * 59 + Id.GetHashCode();
}
if (ResourceState != null)
{
hashCode = hashCode * 59 + ResourceState.GetHashCode();
}
if (Primary != null)
{
hashCode = hashCode * 59 + Primary.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (Distance != null)
{
hashCode = hashCode * 59 + Distance.GetHashCode();
}
return(hashCode);
}
}
public async Task <IActionResult> Post(string groupId, string resourceId, string actionname, uint?duration = null)
{
ScampResource res = await _resourceRepository.GetResource(resourceId);
if (res == null)
{
return(new HttpStatusCodeResult(404)); // not found
}
ResourceAction action = WebJobController.GetAction(actionname);
ResourceState newState = ResourceState.Unknown;
switch (action)
{
case ResourceAction.Start:
newState = ResourceState.Starting;
break;
case ResourceAction.Stop:
newState = ResourceState.Stopping;
break;
}
if (await CanManageResource(res, action))
{
await _volatileStorageController.UpdateResourceState(resourceId, newState);
_webJobController.SubmitActionInQueue(resourceId, action, duration);
}
return(new HttpStatusCodeResult(204));
}
/// <summary>
/// Determines if a given <see cref="ResourceState"/> is invalid, which means it contains both write and read states, or multiple write states
/// </summary>
public static bool IsInvalid(this ResourceState flags)
{
int numWriteFlags = BitOperations.PopCount((uint)(flags & ResourceState.AllWritableFlags));
// you can only have 1 or 0 write flags
// you can have multiple read flags, but only if there are no write flags
return(numWriteFlags > 1 || (numWriteFlags == 1 && flags.HasReadOnlyFlags()));
}
/// <summary>
/// Attempts to add another <see cref="ResourceState"/> to the barrier
/// </summary>
/// <param name="add">The <see cref="ResourceState"/> to try and add</param>
/// <returns><see langword="true"/> if it succeeded, else <see langword="false"/></returns>
public bool TryAddState(ResourceState add)
{
if (add.IsReadOnly() && ((ResourceState)Barrier.Anonymous.Transition.StateAfter).IsReadOnly())
{
Barrier.Anonymous.Transition.StateAfter |= (D3D12_RESOURCE_STATES)add;
return(true);
}
return(false);
}
void InitializeResources()
{
ResourceState rs = FindObjectOfType <ResourceState>();
_wood = rs.nWood;
_iron = rs.nIron;
_food = rs.nFood;
_weapons = rs.nWeapons;
}
public async Task Load(TIn input)
{
_state.Value = ResourceState.FromLoading(true);
try {
_state.Value = ResourceState.FromData(await _execute(input));
} catch (Exception ex) {
_state.Value = ResourceState.FromException(ex);
}
}
public ThemeSwitcher(string assemblyDir = null)
{
var reader = new CacheableResourceReader <Theme>();
var rootDir = assemblyDir ?? Directory.GetParent(Assembly.GetCallingAssembly().Location).ToString();
var themeDir = Path.Combine(rootDir, "Themes");
var resources = new ResourceDirectory <Theme>(new ThemeKeyValueGenerator(), themeDir, "*.xaml");
_finder = new ResourceFinder <Theme>(resources);
_state = new ResourceState <Theme>(new ResourceUpdater <Theme>(reader, Application.Current.Resources.MergedDictionaries));
}
public ResourceButtonViewModel(ResourceScreenItem model, ResourceScreen screen,
ICommand actionCommand, bool isTicketSelected, bool userPermittedToMerge, ResourceState state)
{
_actionCommand = actionCommand;
_screen = screen;
_isTicketSelected = isTicketSelected;
_userPermittedToMerge = userPermittedToMerge;
AccountState = state;
Model = model;
}
public Localizer(string assemblyDir = null)
{
var reader = new ResourceReader <Language>();
var rootDir = assemblyDir ?? Directory.GetParent(Assembly.GetCallingAssembly().Location).ToString();
var dirPath = Path.Combine(rootDir, "Languages");
var resources = new ResourceDirectory <Language>(new LanguageKeyValueGenerator(), dirPath, "*.xaml");
_finder = new ResourceFinder <Language>(resources);
_state = new ResourceState <Language>(new ResourceUpdater <Language>(reader, Application.Current.Resources.MergedDictionaries));
}
/// <summary>
/// checks if the finished conditions are not already fulfilled
/// </summary>
/// <returns></returns>
public bool NeedsToExecute()
{
// it needs to excecute if there are no finish conditions
if (FinishConditions == null)
{
return(true);
}
// evaluate every finishcondition (return true if the evaluation is false)
return(!ResourceState.Evaluate(FinishConditions));
}
public void MarkPersistent(string item)
{
ResourceState state;
if (!_itemCounts.TryGetValue(item, out state))
{
state = new ResourceState();
_itemCounts[item] = state;
}
state.Persist = true;
}
public Resource(Guid id, Guid?containerId, Guid?storageId, Guid?traderId, Type type, ResourceSubtype subtype, ResourceState state, Vector3D position, QuaternionD rotation)
{
Id = id;
ContainerId = containerId;
StorageId = storageId;
TraderId = traderId;
Type = type ?? throw new ArgumentNullException(nameof(type));
Subtype = subtype;
State = state;
Position = position;
Rotation = rotation;
}
void Awake()
{
// Singleton code
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
public void SetResourceState(ResourceState newResState)
{
if (null != newResState)
{
newResState.AddRef();
}
if (null != resState)
{
resState.SubRef();
}
resState = newResState;
}
private void Start()
{
PreviousResources = ResourceState.High;
providers = new ResourceContainer();
OnResource += OnProviderResource;
if (GetComponent <TimeUpdate>() is TimeUpdate timer)
{
timer.OnTick += OnTick;
}
;
}
public void Collect(string item)
{
ResourceState state;
if (!_itemCounts.TryGetValue(item, out state))
{
state = new ResourceState();
_itemCounts[item] = state;
}
state.Count++;
OnResourceChange.Invoke(item, state.Count);
}
private bool NextActivityIsEqual(ResourceState resourceState, string activityKey)
{
var nextActivity = resourceState.ActivityQueue.Peek();
if (nextActivity == null)
{
Agent.DebugMessage($"No next activity for {resourceState.ResourceDefinition.Name} in resource activity queue");
return(false);
}
Agent.DebugMessage($"Next activity is {nextActivity.GetKey} but should be {activityKey} ");
return(nextActivity.GetKey == activityKey);
}
public static string GetLocalizedText(this ResourceState <Language> state, string key)
{
var translatedText = Application.Current.TryFindResource(key);
if (translatedText is string)
{
return(translatedText as string);
}
else
{
return("Laguage files may be broken. Please reinstall.");
}
}
public bool SetResourceDetails(string ResourceUrl, ResourceState resourceState)
{
ResourceDetails resourceDetails = this.dictRegisteredResources.Values.
Where(resource => resource.ResourceUrl.Equals(ResourceUrl)).
FirstOrDefault();
if (resourceDetails != null)
{
resourceDetails.State = resourceState;
return(true);
}
return(false);
}
/// <summary>
/// Converts a semi state code to its E10 equivalent.
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
public static ResourceState GetSemiE58State(ResourceState state)
{
ResourceState result = ResourceState.NST;
int code = ((int)state / 100) * 100;
result = (ResourceState)code;
if (!System.Enum.IsDefined(typeof(ResourceState), result))
{
result = ResourceState.NST;
}
return(result);
}
public static ResourceStates ToResourceStates(this ResourceState value)
{
switch (value)
{
case ResourceState.RenderTarget:
return(ResourceStates.RenderTarget);
case ResourceState.Present:
return(ResourceStates.Present);
default:
throw new ArgumentOutOfRangeException();
}
}
public static D3D12_RESOURCE_STATES GetD3D12ResourceStates(ResourceState resourceState)
{
if (resourceState == ResourceState.ReadOnly)
{
return(D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
}
if (resourceState == ResourceState.ReadWrite)
{
return(D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
return(ThrowHelper.ThrowArgumentException <D3D12_RESOURCE_STATES>("The target resource state is not valid."));
}
private void btnSendMsg_Click(object sender, EventArgs e)
{
if (!theEndpoint.IsOpen)
{
return;
}
List <CFXEnvelope> messages = new List <CFXEnvelope>();
//WorkStarted ws = new WorkStarted();
//ws.TransactionID = Guid.NewGuid();
//ws.Lane = "Lane1";
//ws.Units.Add(new UnitPosition() { UnitIdentifier = "11122456", PositionNumber = 1, PositionName = "1" });
//messages.Add(CFXEnvelope.FromCFXMessage(ws));
//WorkCompleted wc = new WorkCompleted();
//wc.TransactionID = ws.TransactionID;
//wc.Result = WorkResult.Failed;
//messages.Add(CFXEnvelope.FromCFXMessage(wc));
ResourceState[] states = new ResourceState []
{
ResourceState.SDT_Setup,
ResourceState.PRD_RegularWork,
ResourceState.SBY_NoProduct
};
ResourceState newState = lastState;
Random r = new Random();
while (newState == lastState)
{
newState = states[r.Next(0, 2)];
}
CFXEnvelope env = new CFXEnvelope(new StationStateChanged()
{
NewState = newState,
OldState = lastState,
OldStateDuration = DateTime.Now - lastStateChange
});
messages.Add(env);
lastState = (env.MessageBody as StationStateChanged).NewState;
lastStateChange = DateTime.Now;
//theEndpoint.Publish(ws);
theEndpoint.PublishMany(messages);
}
void SaveResourceState()
{
ResourceState rs = FindObjectOfType <ResourceState>();
if (!rs)
{
return;
}
rs.nWood = _wood;
rs.nIron = _iron;
rs.nFood = _food;
rs.nWeapons = _weapons;
}
internal IEnumerator Load()
{
state = ResourceState.Downloading;
www = new WWW(url);
yield return www;
if (Disposed)
yield break;
state = ResourceState.Downloaded;
yield return AfterLoad();
}
public async Task<DomainClientForAdmin> SetStateAsync(string id, ResourceState state)
{
// Update company
CompanyEntity company = await _companyRepository.GetAsync(id);
if (company == null)
{
throw new NotFoundException();
}
company.State = (int)state;
await _companyRepository.UpdateAsync(company);
// Update users
await Task.WhenAll(company.Users.Select(async p =>
{
UserEntity user = await _userRepository.GetAsync(p);
user.State = (int)state;
await _userRepository.UpdateAsync(user);
}));
return await GetClientDataAsync(company);
}
public async Task UpdateResourceState(string resourceId, ResourceState state)
{
// get current resource state
CurrentResourceState updatedState = await this.GetResourceState(resourceId);
if (updatedState == null)
updatedState = new CurrentResourceState(resourceId);
// update with new state
updatedState.State = state;
// save update
await UpdateResourceState(updatedState);
}
internal IEnumerator AfterLoad()
{
// 从Preload处恢复的时候，Preload很可能还没有加载完
while (!www.isDone)
{
if (Disposed)
yield break;
yield return null;
}
string error = www.error;
byte[] rawData = www.bytes;
www.Dispose();
www = null;
if (string.IsNullOrEmpty(error))
{
yield return OnDownloaded(rawData);
}
else
{
loadFailed = true;
Log.Error("资源加载错误! Url:", url, "\nType:", GetType(), "\nError:", error);
state = ResourceState.Complete;
NotifyComplete();
}
}
internal void CopyFrom(PreloadResource preloaded)
{
this.url = preloaded.url;
this.state = preloaded.state;
this.loadFailed = preloaded.loadFailed;
// 把preload的www的所有权转移给自己
this.www = preloaded.www;
preloaded.www = null;
}
internal IEnumerator OnDownloaded(byte[] rawData)
{
this.rawData = rawData;
// not implement
// unpack here
yield return OnPrepareData();
if (Disposed)
yield break;
state = ResourceState.Complete;
NotifyComplete();
}
protected override void OnDispose()
{
OnLoadComplete = null;
if (www != null)
{
www.Dispose();
www = null;
}
manager.RemoveResource(this);
manager = null;
state = ResourceState.Disposed;
base.OnDispose();
}
/// <summary>
/// Attempts to harvest the resource type associated with this world resource for the amount specified and drops
/// it into the resource container "resource"
/// </summary>
/// <param name="resource">The resource container</param>
/// <param name="amount">The amount of that resource to move</param>
private void HarvestResource(Resource resource, int amount)
{
if (ResourceState == global::ResourceState.Active)
{
if (!isInfinite)
currentAmount = Mathf.Clamp( (currentAmount - amount) + resource.AddResource(this.resource, amount), 0, maxAmount);
else
resource.AddResource(this.resource, amount);
if (currentAmount == 0 && !isInfinite)
ResourceState = global::ResourceState.Dying;
if (!isInfinite && !regenerates && currentAmount == 0)
{
ResourceState = global::ResourceState.Dying;
}
}
}
