static void CreateDestructorReferences()
{
for (int i = 0; i < 1000; i++)
{
_ = new Destructor();
}
}
public override void add_destructor(Destructor d)
{
if (d.binding == MemberBinding.INSTANCE)
{
if (destructor != null)
{
Report.error(d.source_reference, "class already contains a destructor");
}
destructor = d;
}
else if (d.binding == MemberBinding.CLASS)
{
if (class_destructor != null)
{
Report.error(d.source_reference, "class already contains a class destructor");
}
class_destructor = d;
}
else
{
if (static_destructor != null)
{
Report.error(d.source_reference, "class already contains a static destructor");
}
static_destructor = d;
}
}
protected PoolBase(object reference, Type type, Constructor constructor, Destructor destructor, int startSize, bool initialize)
{
PoolUtility.InitializeJanitor();
this.reference = reference;
this.constructor = constructor ?? Construct;
this.destructor = destructor ?? Destroy;
this.startSize = startSize;
Type = type;
isPoolable = reference is IPoolable;
hashedInstances = new HashSet <object>();
if (ApplicationUtility.IsMultiThreaded)
{
updater = new AsyncPoolUpdater();
}
else
{
updater = new SyncPoolUpdater();
}
if (initialize)
{
Initialize();
}
}
override public void OnDestructor(Destructor node)
{
Method finalizer = CodeBuilder.CreateMethod(
"Finalize",
TypeSystemServices.VoidType,
TypeMemberModifiers.Protected | TypeMemberModifiers.Override);
finalizer.LexicalInfo = node.LexicalInfo;
MethodInvocationExpression mie = new MethodInvocationExpression(new SuperLiteralExpression());
Block bodyNew = new Block();
Block ensureBlock = new Block();
ensureBlock.Add(mie);
TryStatement tryStatement = new TryStatement();
tryStatement.EnsureBlock = ensureBlock;
tryStatement.ProtectedBlock = node.Body;
bodyNew.Add(tryStatement);
finalizer.Body = bodyNew;
node.ParentNode.Replace(node, finalizer);
}
void getComponentReferences()
{
floorAttachingMovement = GetComponent <FloorAttachMovement>();
animationManager = GetComponent <AnimationManager>();
blockDestructor = GetComponent <Destructor>();
rigidbody = GetComponent <Rigidbody2D>();
collider = GetComponent <CapsuleCollider2D>();
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.tag.Equals("Ball"))
{
Destructor.Destroy(collision.gameObject);
SceneLoader.ChangeScene(SceneLoader.GAMEOVER);
}
}
/// <summary>
/// Adds the given destructor to the given type.
/// </summary>
/// <param name="type">The entity to add the fields to.</param>
/// <param name="tp">.</param>
private void AddDestructors(CompositeType type, TypeDeclaration tp)
{
foreach (DestructorDeclaration dp in tp.Descendants.OfType <DestructorDeclaration>())
{
Destructor des = type.AddDestructor();
des.Name = dp.Name;
}
}
// Use this for initialization
void Start()
{
//Get components
m_col = GetComponent <CapsuleCollider2D>();
m_rb = GetComponent <Rigidbody2D>();
m_anim = GetComponent <AnimationManager>();
m_destr = GetComponent <Destructor>();
m_destr.enabled = false;
}
public static void InitDestructorMap(Destructor destructor)
{
var bounds = destructor.GetComponent <BoxCollider2D>().bounds;
var min = Vector3.zero - bounds.extents;
var size = bounds.size;
DestructorMap = new BoxMap(min, size);
}
public StudyPage()
{
InitializeComponent();
#region AnimationsInit
Task.WhenAll(
CSharpDef.FadeTo(0, 1),
definitions.FadeTo(0, 1),
progLang.FadeTo(0, 1),
OOP.FadeTo(0, 1),
DotNETFramework.FadeTo(0, 1),
clr.FadeTo(0, 1),
cls.FadeTo(0, 1),
cts.FadeTo(0, 1),
MSIL.FadeTo(0, 1),
JIT.FadeTo(0, 1),
Compiler.FadeTo(0, 1),
SourceCode.FadeTo(0, 1),
ExecutableCode.FadeTo(0, 1),
boxview1.FadeTo(0, 1),
generalProgTerms.FadeTo(0, 1),
Variables.FadeTo(0, 1),
DataType.FadeTo(0, 1),
Keywords.FadeTo(0, 1),
Operators.FadeTo(0, 1),
Expression.FadeTo(0, 1),
TypeCasting.FadeTo(0, 1),
Arrays.FadeTo(0, 1),
Function.FadeTo(0, 1),
Class.FadeTo(0, 1),
Object.FadeTo(0, 1),
Constructor.FadeTo(0, 1),
Destructor.FadeTo(0, 1),
Namespaces.FadeTo(0, 1),
Exceptions.FadeTo(0, 1),
ExceptionHandling.FadeTo(0, 1),
boxview2.FadeTo(0, 1),
oopProgTerms.FadeTo(0, 1),
Inheritance.FadeTo(0, 1),
BaseClass.FadeTo(0, 1),
DerivedClass.FadeTo(0, 1),
AbstractClass.FadeTo(0, 1),
MultilevelInheritance.FadeTo(0, 1),
HierarchicalInheritance.FadeTo(0, 1),
SingleInheritance.FadeTo(0, 1),
Interface.FadeTo(0, 1),
Polymorphism.FadeTo(0, 1),
Overriding.FadeTo(0, 1),
Encapsulation.FadeTo(0, 1),
Abstraction.FadeTo(0, 1),
Overloading.FadeTo(0, 1));
#endregion
// App.adCounter = 0;
}
public void MinaNoDeberiaDestruirParte()
{
var posicion = new Posicion ('e', 5);
var destructor = new Destructor (posicion, Direccion.Norte, TestHelper.AreaDePosicionesValidasDefault);
Assert.AreEqual (0, destructor.PosicionesDePartesDestruidas.Count());
destructor.DaniarConMina (new[] { posicion });
Assert.AreEqual (0, destructor.PosicionesDePartesDestruidas.Count());
}
public void DisparoDirectoDeberiaDestruirParte()
{
var posicion = new Posicion ('e', 5);
var destructor = new Destructor (posicion, Direccion.Norte, TestHelper.AreaDePosicionesValidasDefault);
Assert.AreEqual (0, destructor.PosicionesDePartesDestruidas.Count());
destructor.DaniarConDisparoConvencional (posicion);
Assert.AreEqual (1, destructor.PosicionesDePartesDestruidas.Count());
}
public static void Main(String[] args)
{
ForDispose fd = new ForDispose();
fd.Dispose();
Destructor des = new Destructor();
UsingExample ue = new UsingExample();
ue.Method();
Console.ReadLine();
}
override public void LeaveDestructor(Destructor node)
{
if (node.Modifiers != TypeMemberModifiers.None)
{
Error(CompilerErrorFactory.InvalidDestructorModifier(node));
}
if (node.Parameters.Count != 0)
{
Error(CompilerErrorFactory.CantHaveDestructorParameters(node));
}
}
protected async override void OnAppearing()
{
#region AnimationsFadeIn
await Task.WhenAll(
CSharpDef.FadeTo(1, 500),
definitions.FadeTo(1, 500),
progLang.FadeTo(1, 500),
OOP.FadeTo(1, 500),
DotNETFramework.FadeTo(1, 500),
clr.FadeTo(1, 500),
cls.FadeTo(1, 500),
cts.FadeTo(1, 500),
MSIL.FadeTo(1, 500),
JIT.FadeTo(1, 500),
Compiler.FadeTo(1, 500),
SourceCode.FadeTo(1, 500),
ExecutableCode.FadeTo(1, 500),
boxview1.FadeTo(1, 500),
generalProgTerms.FadeTo(1, 500),
Variables.FadeTo(1, 500),
DataType.FadeTo(1, 500),
Keywords.FadeTo(1, 500),
Operators.FadeTo(1, 500),
Expression.FadeTo(1, 500),
TypeCasting.FadeTo(1, 500),
Arrays.FadeTo(1, 500),
Function.FadeTo(1, 500),
Class.FadeTo(1, 500),
Object.FadeTo(1, 500),
Constructor.FadeTo(1, 500),
Destructor.FadeTo(1, 500),
Namespaces.FadeTo(1, 500),
Exceptions.FadeTo(1, 500),
ExceptionHandling.FadeTo(1, 500),
boxview2.FadeTo(1, 500),
oopProgTerms.FadeTo(1, 500),
Inheritance.FadeTo(1, 500),
BaseClass.FadeTo(1, 500),
DerivedClass.FadeTo(1, 500),
AbstractClass.FadeTo(1, 500),
MultilevelInheritance.FadeTo(1, 500),
HierarchicalInheritance.FadeTo(1, 500),
SingleInheritance.FadeTo(1, 500),
Interface.FadeTo(1, 500),
Polymorphism.FadeTo(1, 500),
Overriding.FadeTo(1, 500),
Encapsulation.FadeTo(1, 500),
Abstraction.FadeTo(1, 500),
Overloading.FadeTo(1, 500));
#endregion
}
static DriveManager()
{
Finalise = new Destructor();
Disks = new Dictionary <String, DriveInfo>();
watcher = new ManagementEventWatcher();
watcher.Query = new WqlEventQuery("SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 2 or EventType = 3");
watcher.EventArrived += new EventArrivedEventHandler(DriveFoundEvent);
watcher.Start();
watcher.Stop();
RefreshDrives();
}
public override object VisitDestructorDeclaration(AST.DestructorDeclaration destructorDeclaration, object data)
{
DomRegion region = GetRegion(destructorDeclaration.StartLocation, destructorDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(destructorDeclaration.EndLocation, destructorDeclaration.Body != null ? destructorDeclaration.Body.EndLocation : RefParser.Location.Empty);
DefaultClass c = GetCurrentClass();
Destructor destructor = new Destructor(region, bodyRegion, c);
ConvertAttributes(destructorDeclaration, destructor);
c.Methods.Add(destructor);
return(null);
}
public void TresDisparosConvencionalesDeberianDestruirDestructor()
{
var posicion = new Posicion ('e', 5);
var destructor = new Destructor (posicion, Direccion.Norte, TestHelper.AreaDePosicionesValidasDefault);
Assert.AreEqual (0, destructor.PosicionesDePartesDestruidas.Count());
destructor.DaniarConDisparoConvencional (new Posicion('e', 5));
destructor.DaniarConDisparoConvencional (new Posicion('e', 4));
destructor.DaniarConDisparoConvencional (new Posicion('e', 3));
Assert.IsTrue (destructor.Destruida);
Assert.AreEqual (3, destructor.PosicionesDePartesDestruidas.Count());
Assert.AreEqual (0, destructor.PosicionesDePartesSanas.Count());
}
public void DeberiaInicializarCorrectamenteLosAtributos ()
{
var posicion = new Posicion ('e', 5);
var destructor = new Destructor (posicion, Direccion.Este, TestHelper.AreaDePosicionesValidasDefault);
Assert.AreEqual (3, destructor.Tamanio);
Assert.IsTrue (destructor.PosicionesOcupadas.Any(p => p.Equals(new Posicion('e', 5))));
Assert.IsTrue (destructor.PosicionesOcupadas.Any(p => p.Equals(new Posicion('f', 5))));
Assert.IsTrue (destructor.PosicionesOcupadas.Any(p => p.Equals(new Posicion('g', 5))));
Assert.AreEqual (Direccion.Este, destructor.Direccion);
Assert.IsFalse (destructor.Destruida);
Assert.AreEqual (3, destructor.PosicionesDePartesSanas.Count());
Assert.AreEqual (0, destructor.PosicionesDePartesDestruidas.Count());
}
void Start()
{
controller = GetComponent <Controller2D>();
m_anim = GetComponent <AnimationManager>();
m_destr = GetComponent <Destructor>();
m_destr.enabled = false;
gravity = 1;
maxJumpVelocity = Mathf.Abs(gravity) * timeToJumpApex;
minJumpVelocity = Mathf.Sqrt(2 * Mathf.Abs(gravity) * minJumpHeight);
print("Gravity: " + gravity + " Jump Velocity: " + maxJumpVelocity);
controller.maxSlopeAngle = maxSlopeAngle;
}
public void A_Destructor_Is_Created()
{
// This should not be the name of the class
const string code = "public ~MadeUpClassName() { }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.DestructorDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Destructor)));
Destructor con = (Destructor)bc;
Assert.That(con.Name, Is.EqualTo("MadeUpClassName"));
Assert.That(con.BodyText, Is.EqualTo("{\n}\n".Replace("\n", Environment.NewLine)));
}
protected PoolBase(object reference, Type type, Constructor constructor, Destructor destructor, int startSize, bool initialize)
{
PoolUtility.InitializeJanitor();
this.reference = reference;
this.constructor = constructor ?? Construct;
this.destructor = destructor ?? Destroy;
this.startSize = startSize;
Type = type;
isPoolable = reference is IPoolable;
hashedInstances = new HashSet<object>();
if (ApplicationUtility.IsMultiThreaded)
updater = new AsyncPoolUpdater();
else
updater = new SyncPoolUpdater();
if (initialize)
Initialize();
}
static JpegTools()
{
var dllFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dll);
_finalise = new Destructor();
if (!File.Exists(dllFile))
{
if (IntPtr.Size == 8)
{
File.WriteAllBytes(dllFile, Resources.native_libjpeg_x64);
}
else
{
File.WriteAllBytes(dllFile, Resources.native_libjpeg_x86);
}
}
_lib = LoadLibrary(dllFile);
if (_lib == IntPtr.Zero)
{
throw new DllNotFoundException(dll);
}
}
internal static void destructor_location(this TextWriter trapFile, Destructor destructor, Location location)
{
trapFile.WriteTuple("destructor_location", destructor, location);
}
override public void OnDestructor(Destructor c)
{
OnMethod(c);
}
override public void OnDestructor(Destructor node)
{
OnMethod(node);
}
public virtual void Visit(Destructor d)
{
}
public override object VisitDestructorDeclaration(AST.DestructorDeclaration destructorDeclaration, object data)
{
DomRegion region = GetRegion(destructorDeclaration.StartLocation, destructorDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(destructorDeclaration.EndLocation, destructorDeclaration.Body != null ? destructorDeclaration.Body.EndLocation : RefParser.Location.Empty);
DefaultClass c = GetCurrentClass();
Destructor destructor = new Destructor(region, bodyRegion, c);
ConvertAttributes(destructorDeclaration, destructor);
c.Methods.Add(destructor);
return null;
}
/// <summary>
/// Checks a destructor to ensure that the summary text matches the expected text.
/// </summary>
/// <param name="destructor">The destructor to check.</param>
/// <param name="formattedDocs">The formatted header documentation.</param>
private void CheckDestructorSummaryText(Destructor destructor, XmlDocument formattedDocs)
{
Param.AssertNotNull(destructor, "destructor");
Param.AssertNotNull(formattedDocs, "formattedDocs");
XmlNode node = formattedDocs.SelectSingleNode("root/summary");
if (node != null)
{
string summaryText = node.InnerXml.Trim();
// Get a regex to match the type name.
ClassBase parent = destructor.Parent as ClassBase;
if (parent != null)
{
string typeRegex = BuildCrefValidationStringForType(parent);
// Get the full expected summary text.
string expectedRegex = GetExpectedSummaryTextForDestructor(typeRegex);
if (!Regex.IsMatch(summaryText, expectedRegex))
{
this.AddViolation(
destructor,
Rules.DestructorSummaryDocumentationMustBeginWithStandardText,
GetExampleSummaryTextForDestructor());
}
}
}
}
internal static void destructors(this TextWriter trapFile, Destructor destructor, string name, Type containingType, Destructor original)
{
trapFile.WriteTuple("destructors", destructor, name, containingType, original);
}
public static void test() {
#pragma warning disable 281
var obj = new Destructor();
}
public override void OnDestructor(Destructor node)
{
CheckExtensionSemantics(node);
}
internal static Tuple destructors(Destructor destructor, string name, Type containingType, Destructor original) => new Tuple("destructors", destructor, name, containingType, original);
internal static Tuple destructor_location(Destructor destructor, Location location) => new Tuple("destructor_location", destructor, location);
