public override bool VisitEnumDecl(Enumeration @enum)
{
if (!VisitDeclaration(@enum))
return false;
if ([email protected])
goto Out;
if (@enum.CompleteDeclaration != null)
goto Out;
@enum.CompleteDeclaration =
AstContext.FindCompleteEnum(@enum.QualifiedName);
if (@enum.CompleteDeclaration == null)
{
@enum.GenerationKind = GenerationKind.Internal;
Driver.Diagnostics.EmitWarning(DiagnosticId.UnresolvedDeclaration,
"Unresolved declaration: {0}", @enum.Name);
}
Out:
return base.VisitEnumDecl(@enum);
}
public Chomper(RoomNew room, ContentManager Content, Enumeration.TileType tileType, Enumeration.StateTile state, Enumeration.TileType NextTileType__1)
{
base.room = room;
nextTileType = NextTileType__1;
System.Xml.Serialization.XmlSerializer ax = new System.Xml.Serialization.XmlSerializer(tileSequence.GetType());
Stream txtReader = Microsoft.Xna.Framework.TitleContainer.OpenStream(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + tileType.ToString().ToUpper() + "_sequence.xml");
tileSequence = (List<Sequence>)ax.Deserialize(txtReader);
foreach (Sequence s in tileSequence)
{
s.Initialize(Content);
}
//Search in the sequence the right type
//Sequence result = tileSequence.Find((Sequence s) => s.name.ToUpper() == state.ToString().ToUpper());
Sequence result = tileSequence.Find((Sequence s) => s.name == state.ToString().ToUpper());
if (result != null)
{
result.frames[0].SetTexture(Content.Load<Texture2D>(PrinceOfPersiaGame.CONFIG_TILES[0] + result.frames[0].value));
collision = result.collision;
Texture = result.frames[0].texture;
}
Type = tileType;
//change statetile element
tileState.Value().state = state;
tileAnimation.PlayAnimation(tileSequence, tileState.Value());
}
public void DocumentEnum(Enumeration @enum)
{
string file = GetFileForDeclarationContext(@enum.Namespace);
if (this.documentation.ContainsKey(file))
{
string typeDocs = this.documentation[file];
const string enumDoc = @"enum {0}(\s*flags {1}::\w+\s+)?(?<docsStart>.*?)(\n){{3}}";
string enumName = string.IsNullOrEmpty(@enum.Namespace.Name) ? @enum.Name : (@enum.Namespace.Name + "::" + @enum.Name);
Match matchEnum = Regex.Match(typeDocs, string.Format(enumDoc, enumName, @enum.Namespace.Name),
RegexOptions.Singleline | RegexOptions.ExplicitCapture);
if (matchEnum.Success)
{
string doc = matchEnum.Groups["docsStart"].Value.Trim();
if (!string.IsNullOrEmpty(doc))
{
doc = Regex.Replace(doc,
@"(The \S+ type is a typedef for QFlags<\S+>\. It stores an OR combination of \S+ values\.)",
string.Empty);
doc = Regex.Replace(doc, @"ConstantValue(Description)?.*?(((\n){2})|$)", string.Empty,
RegexOptions.Singleline | RegexOptions.ExplicitCapture).Trim();
@enum.Comment = new RawComment();
@enum.Comment.BriefText = doc;
}
}
}
foreach (Enumeration.Item item in @enum.Items)
{
this.DocumentEnumItem(@enum, item);
}
}
public static Schema.KRPC.Services GetServices()
{
var services = new Schema.KRPC.Services ();
foreach (var serviceSignature in Services.Instance.Signatures.Values) {
var service = new Schema.KRPC.Service ();
service.Name = serviceSignature.Name;
foreach (var procedureSignature in serviceSignature.Procedures.Values) {
var procedure = new Procedure ();
procedure.Name = procedureSignature.Name;
if (procedureSignature.HasReturnType)
{
procedure.HasReturnType = true;
procedure.ReturnType = TypeUtils.GetTypeName (procedureSignature.ReturnType);
}
foreach (var parameterSignature in procedureSignature.Parameters) {
var parameter = new Parameter ();
parameter.Name = parameterSignature.Name;
parameter.Type = TypeUtils.GetTypeName (parameterSignature.Type);
if (parameterSignature.HasDefaultArgument)
{
parameter.HasDefaultArgument = true;
parameter.DefaultArgument = parameterSignature.DefaultArgument;
}
procedure.Parameters.Add (parameter);
}
foreach (var attribute in procedureSignature.Attributes) {
procedure.Attributes.Add (attribute);
}
if (procedureSignature.Documentation != "")
procedure.Documentation = procedureSignature.Documentation;
service.Procedures.Add (procedure);
}
foreach (var clsSignature in serviceSignature.Classes.Values) {
var cls = new Class ();
cls.Name = clsSignature.Name;
if (clsSignature.Documentation != "")
cls.Documentation = clsSignature.Documentation;
service.Classes.Add (cls);
}
foreach (var enmSignature in serviceSignature.Enumerations.Values) {
var enm = new Enumeration ();
enm.Name = enmSignature.Name;
if (enmSignature.Documentation != "")
enm.Documentation = enmSignature.Documentation;
foreach (var enmValueSignature in enmSignature.Values) {
var enmValue = new EnumerationValue ();
enmValue.Name = enmValueSignature.Name;
enmValue.Value = enmValueSignature.Value;
if (enmValueSignature.Documentation != "")
enmValue.Documentation = enmValueSignature.Documentation;
enm.Values.Add (enmValue);
}
service.Enumerations.Add (enm);
}
if (serviceSignature.Documentation != "")
service.Documentation = serviceSignature.Documentation;
services.Services_.Add (service);
}
return services;
}
static bool IsFlagEnum(Enumeration @enum)
{
// If the enumeration only has power of two values, assume it's
// a flags enum.
var isFlags = true;
var hasBigRange = false;
foreach (var item in @enum.Items)
{
var value = item.Value;
if (value >= 4)
hasBigRange = true;
if (value <= 1 || value.IsPowerOfTwo())
continue;
isFlags = false;
}
// Only apply this heuristic if there are enough values to have a
// reasonable chance that it really is a bitfield.
return isFlags && hasBigRange;
}
public bool LogMessage(Enumeration.LoggingPriority priority, string transactionReference, Exception exception)
{
try
{
StringBuilder s = new StringBuilder();
s.AppendFormat("Exception: {0} |", String.IsNullOrEmpty(exception.Message) ? "NONE" : exception.Message);
if (exception.InnerException != null)
{
s.AppendFormat("Inner Exception Message: {0} |", String.IsNullOrEmpty(exception.InnerException.Message) ? "NONE" : exception.InnerException.Message);
s.AppendFormat("Inner Exception Source: {0} |", String.IsNullOrEmpty(exception.InnerException.Source) ? "NONE" : exception.InnerException.Source);
}
s.AppendFormat("Exception Source: {0} |", String.IsNullOrEmpty(exception.Source) ? "NONE" : exception.Source);
s.AppendFormat("Exception Stack Trace: {0} ", String.IsNullOrEmpty(exception.StackTrace) ? "NONE" : exception.StackTrace);
LoggingRequest lsmr = new LoggingRequest
{
TransactionReference = transactionReference,
LoggingPriority = priority,
Message = s.ToString(),
TimeStamp = DateTime.Now
};
//Call the Repo and insert the data (LoggingServiceRequest)
return true;
}
catch
{
// do nothing
return false;
}
}
public MainPage()
{
this.InitializeComponent();
HIDEnum = new Enumeration(this.NotifyUser);
GetUagePageInfo();
////JObject o1 = JObject.Parse(File.ReadAllText(".\\usagepage.json"));
//using (StreamReader file = File.OpenText(".\\usagepage.json"))
//using(JsonTextReader reader = new JsonTextReader(file))
//{
// JObject jObject = (JObject)JToken.ReadFrom(reader);
// var hidUsageClasses =
// from p in jObject["hidUsageClasses"]
// select new UsagePage ((string)p["PageName"],(ushort)p["PageID"] );
// UsagePages = hidUsageClasses.ToList<UsagePage>();
// var hidDeviceClasses =
// from p in jObject["hidDeviceClasses"]
// select new HidDeviceClass((string)p["UsageName"], (ushort)p["PageID"], (ushort)p["UsageID"]);
// HidDeviceClasses = hidDeviceClasses.ToList<HidDeviceClass>();
// cbDevType.DataContext = HidDeviceClasses;
//}
}
public StateTileElement(Enumeration.StateTile state, Enumeration.PriorityState priority__1, Enumeration.SequenceReverse reverse__2)
{
_state = state;
Priority = priority__1;
Reverse = reverse__2;
OffSet = Vector2.Zero;
}
public StateTileElement(Enumeration.StateTile state, Enumeration.PriorityState priority__1)
{
_state = state;
Priority = priority__1;
Reverse = Enumeration.SequenceReverse.Normal;
OffSet = Vector2.Zero;
}
public Template(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, Enumeration e)
: base(_host)
{
this.ctx = ctx;
this.e = e;
}
public StatePlayerElement(Enumeration.State state, Enumeration.PriorityState priority__1, Vector2 offSet__2)
{
_state = state;
Priority = priority__1;
Reverse = Enumeration.SequenceReverse.Normal;
OffSet = offSet__2;
}
public StateElement(Enumeration.State state)
{
_state = state;
_priorityState = Enumeration.PriorityState.Normal;
_reverse = Enumeration.SequenceReverse.Normal;
_offset = Vector2.Zero;
}
static string GetActionPositionRun(Hands[] hands, int position, int run, Enumeration.Street street)
{
var user = hands.Single(x => x.Position == position).User;
string action;
switch (street)
{
case Enumeration.Street.Blind:
action = hands.Single(x => x.Position == position).ActionBlind;
break;
case Enumeration.Street.Preflop:
action = hands.Single(x => x.Position == position).ActionPreflop;
break;
case Enumeration.Street.Flop:
action = hands.Single(x => x.Position == position).ActionFlop;
break;
case Enumeration.Street.Turn:
action = hands.Single(x => x.Position == position).ActionTurn;
break;
case Enumeration.Street.River:
action = hands.Single(x => x.Position == position).ActionRiver;
break;
default:
throw new ArgumentException("this street does not exist", street.ToString());
}
if (action == string.Empty)
return string.Empty;
if (action.Split(',').Count() > run)
return user + " " + action.Split(',')[run];
return string.Empty;
}
public StateElement(Enumeration.State state, Enumeration.PriorityState priority, Enumeration.SequenceReverse reverse)
{
_state = state;
_priorityState = priority;
_reverse = reverse;
_offset = Vector2.Zero;
}
public StateTileElement(Enumeration.StateTile state, Enumeration.PriorityState priority__1, System.Nullable<bool> stoppable__2)
{
_state = state;
Priority = priority__1;
Stoppable = stoppable__2;
Reverse = Enumeration.SequenceReverse.Normal;
OffSet = Vector2.Zero;
}
public override bool VisitEnumDecl(Enumeration @enum)
{
if (!this.AlreadyVisited(@enum) && @enum.IsGenerated)
{
this.documentation.DocumentEnum(@enum);
}
return base.VisitEnumDecl(@enum);
}
public StateElement(Enumeration.State state, Enumeration.PriorityState priority, System.Nullable<bool> stoppable)
{
_state = state;
_priorityState = priority;
_stoppable = stoppable;
_reverse = Enumeration.SequenceReverse.Normal;
_offset = Vector2.Zero;
}
public override bool VisitEnumItem(Enumeration.Item item)
{
if (!base.VisitEnumItem(item))
return false;
item.Name = CheckName(item.Name);
return true;
}
public override bool VisitEnumDecl(Enumeration @enum)
{
if (!base.VisitEnumDecl(@enum))
return false;
CheckEnumName(@enum);
return true;
}
public StatePlayerElement(Enumeration.State state)
{
_state = state;
Priority = Enumeration.PriorityState.Normal;
Reverse = Enumeration.SequenceReverse.Normal;
OffSet = Vector2.Zero;
IfTrue = false;
}
public StatePlayerElement(Enumeration.State state, Enumeration.PriorityState priority__1, System.Nullable<bool> stoppable__2, Enumeration.SequenceReverse reverse__3)
{
_state = state;
Priority = priority__1;
Stoppable = stoppable__2;
Reverse = reverse__3;
OffSet = Vector2.Zero;
}
public StateTileElement(Enumeration.StateTile state, Enumeration.PriorityState priority__1, System.Nullable<bool> stoppable__2, Enumeration.SequenceReverse reverse__3, Vector2 offSet__4)
{
_state = state;
Priority = priority__1;
Stoppable = stoppable__2;
Reverse = reverse__3;
OffSet = offSet__4;
}
public StateElement(Enumeration.State state, Enumeration.PriorityState priority, System.Nullable<bool> stoppable, Enumeration.SequenceReverse reverse, Vector2 offSet)
{
_state = state;
_priorityState = priority;
_stoppable = stoppable;
_reverse = reverse;
_offset = offSet;
}
public StateTileElement(Enumeration.StateTile state, bool iftrue__1)
{
_state = state;
Priority = Enumeration.PriorityState.Normal;
Reverse = Enumeration.SequenceReverse.Normal;
OffSet = Vector2.Zero;
IfTrue = iftrue__1;
}
public override bool VisitEnumDecl(Enumeration @enum)
{
if (@enum.Comment == null)
{
this.documentation.DocumentEnum(@enum);
}
return base.VisitEnumDecl(@enum);
}
public void GetConstructedUri_Crop_MatchesExpected(Enumeration.CropType cropType)
{
var query = new GetSpartanImage()
.Crop(cropType);
var uri = query.GetConstructedUri();
Assert.AreEqual($"profile/h5/profiles/{null}/spartan?crop={cropType}", uri);
}
public void Add(Enumeration.State state, Enumeration.PriorityState priority, Enumeration.SequenceReverse reverse)
{
if (data.Count == iSize)
{
data.Dequeue();
}
data.Enqueue(new StatePlayerElement(state, priority, reverse));
}
public void GetConstructedUri_Crop_MatchesExpected(Enumeration.CropType cropType)
{
var query = new GetSpartanImage()
.Crop(cropType);
var uri = query.GetConstructedUri();
Assert.AreEqual(string.Format(BaseUri, null, $"?crop={cropType}"), uri);
}
public void Add(Enumeration.State state, Enumeration.PriorityState priority, Vector2 offSet)
{
if (data.Count == iSize)
{
data.Dequeue();
}
data.Enqueue(new StatePlayerElement(state, priority, offSet));
}
public void GetConstructedUri_InGameModes_MatchesExpected(Enumeration.GameMode gameMode1, Enumeration.GameMode gameMode2)
{
var query = new GetMatches()
.InGameModes(new List<Enumeration.GameMode> {gameMode1, gameMode2});
var uri = query.GetConstructedUri();
Assert.AreEqual($"stats/h5/players/{null}/matches?modes={gameMode1},{gameMode2}", uri);
}
private static extern Status yepLibrary_GetString(Enumeration enumeration, uint value, StringType stringType, System.IntPtr buffer, ref System.UIntPtr length);
public override bool VisitEnumDecl(Enumeration @enum)
{
Context.Return.Write("{0}", Context.ReturnVarName);
return(true);
}
public override bool VisitEnumDecl(Enumeration @enum)
{
Context.Return.Write(Context.Parameter.Name);
return(true);
}
public async Task <bool> HandleAsync(EditAatfDetails message)
{
authorization.EnsureCanAccessInternalArea();
authorization.EnsureUserInRole(Roles.InternalAdmin);
using (var transaction = context.BeginTransaction())
{
try
{
var updatedAddress = addressMapper.Map(message.Data.SiteAddress);
var existingAatf = await genericDataAccess.GetById <Aatf>(message.Data.Id);
var competentAuthority = await commonDataAccess.FetchCompetentAuthority(message.Data.CompetentAuthority.Abbreviation);
LocalArea localArea = null;
PanArea panArea = null;
if (message.Data.LocalAreaDataId.HasValue)
{
localArea = await commonDataAccess.FetchLookup <LocalArea>(message.Data.LocalAreaDataId.Value);
}
if (message.Data.PanAreaDataId.HasValue)
{
panArea = await commonDataAccess.FetchLookup <PanArea>(message.Data.PanAreaDataId.Value);
}
var updatedAatf = new Aatf(
message.Data.Name,
competentAuthority,
message.Data.ApprovalNumber,
Enumeration.FromValue <Domain.AatfReturn.AatfStatus>(message.Data.AatfStatusValue),
existingAatf.Organisation,
updatedAddress,
Enumeration.FromValue <Domain.AatfReturn.AatfSize>(message.Data.AatfSizeValue),
message.Data.ApprovalDate.GetValueOrDefault(),
existingAatf.Contact,
existingAatf.FacilityType,
existingAatf.ComplianceYear,
localArea,
panArea);
var existingAddress = await genericDataAccess.GetById <AatfAddress>(existingAatf.SiteAddress.Id);
var country = await organisationDetailsDataAccess.FetchCountryAsync(message.Data.SiteAddress.CountryId);
await aatfDataAccess.UpdateAddress(existingAddress, updatedAddress, country);
if (message.Data.ApprovalDate.HasValue && existingAatf.ApprovalDate.HasValue)
{
var flags = await getAatfApprovalDateChangeStatus.Validate(existingAatf, message.Data.ApprovalDate.Value);
if (flags.HasFlag(CanApprovalDateBeChangedFlags.DateChanged))
{
var existingQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(existingAatf.ApprovalDate.Value);
var newQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(message.Data.ApprovalDate.Value);
var range = Enumerable.Range((int)existingQuarter, (int)newQuarter - 1);
await aatfDataAccess.RemoveAatfData(existingAatf, range);
}
}
await aatfDataAccess.UpdateDetails(existingAatf, updatedAatf);
context.Commit(transaction);
}
catch (Exception ex)
{
transaction.Rollback();
if (ex.InnerException != null)
{
throw ex.InnerException;
}
}
finally
{
context.Dispose(transaction);
}
}
return(true);
}
public override bool VisitEnumDecl(Enumeration @enum)
{
if (!VisitDeclaration(@enum))
{
return(false);
}
PushBlock(BlockKind.Enum, @enum);
GenerateDeclarationCommon(@enum);
if (IsCLIGenerator)
{
if (@enum.Modifiers.HasFlag(Enumeration.EnumModifiers.Flags))
{
WriteLine("[System::Flags]");
}
// A nested class cannot have an assembly access specifier as part
// of its declaration.
if (@enum.Namespace is Namespace)
{
Write("public ");
}
}
var enumKind = @enum.IsScoped || IsCLIGenerator ? "enum class" : "enum";
var enumName = Options.GeneratorKind == GeneratorKind.C ?
QualifiedName(@enum) : @enum.Name;
var generateTypedef = Options.GeneratorKind == GeneratorKind.C;
if (generateTypedef)
{
Write($"typedef {enumKind} {enumName}");
}
else
{
Write($"{enumKind} {enumName}");
}
if (Options.GeneratorKind == GeneratorKind.CPlusPlus ||
Options.GeneratorKind == GeneratorKind.CLI)
{
var typeName = CTypePrinter.VisitPrimitiveType(
@enum.BuiltinType.Type, new TypeQualifiers());
if (@enum.BuiltinType.Type != PrimitiveType.Int &&
@enum.BuiltinType.Type != PrimitiveType.Null)
{
Write($" : {typeName}");
}
}
NewLine();
WriteOpenBraceAndIndent();
GenerateEnumItems(@enum);
Unindent();
if (!string.IsNullOrWhiteSpace(enumName) && generateTypedef)
{
WriteLine($"}} {enumName};");
}
else
{
WriteLine("};");
}
PopBlock(NewLineKind.BeforeNextBlock);
return(true);
}
public override bool VisitEnumDecl(Enumeration @enum)
{
if (!VisitDeclaration(@enum))
{
return(false);
}
if (@enum.IsIncomplete)
{
return(true);
}
PushBlock(BlockKind.Enum);
GenerateDeclarationCommon(@enum);
Write("{0} final class {1} ", AccessIdentifier(@enum.Access), @enum.Name);
WriteStartBraceIndent();
GenerateEnumItems(@enum);
NewLine();
var typeName = @enum.BuiltinType.Visit(TypePrinter);
WriteLine($"private final {typeName} id;");
WriteLine($"{@enum.Name}({typeName} id) {{ this.id = id; }}");
WriteLine($"public {typeName} getValue() {{ return id; }}");
NewLine();
var value = @enum.BuiltinType.IsUnsigned ? "n.intValue()" : "n";
WriteLine($"public static {@enum.Name} fromOrdinal({typeName} n) {{");
WriteLineIndent($"return valuesMap.containsKey({value}) ? valuesMap.get({value}) : new {@enum.Name}(n);");
WriteLine("}");
TypePrinter.PushContext(TypePrinterContextKind.Template);
var refTypeName = @enum.BuiltinType.Visit(TypePrinter);
TypePrinter.PopContext();
NewLine();
WriteLine($"private static final java.util.Map<{refTypeName}, {@enum.Name}> valuesMap = ");
WriteLineIndent($"new java.util.HashMap<{refTypeName}, {@enum.Name}>();");
NewLine();
WriteLine("static {");
PushIndent();
WriteLine("try {");
PushIndent();
WriteLine($"java.lang.reflect.Field[] constants = {@enum.Name}.class.getFields();");
WriteLine($"for (final java.lang.reflect.Field field : constants) {{");
WriteLineIndent($"{@enum.Name} item = ({@enum.Name}) field.get(null);");
WriteLineIndent($"valuesMap.put(item.getValue(), item);");
WriteLine("}");
PopIndent();
WriteLine("} catch(java.lang.IllegalAccessException ex) {");
WriteLine("}");
PopIndent();
WriteLine("}");
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
return(true);
}
public static MaterialType GetMaterialType(int id)
{
var materialTypes = Enumeration.GetAll <MaterialType>().Cast <MaterialType>();
return(materialTypes.FirstOrDefault(x => x.Id == id));
}
