public Delta CreateNMSDelta(ConcreteModel concreteModel)
        {
            if (concreteModel == null || concreteModel.ModelMap == null)
            {
                return(null);
            }

            Delta delta = new Delta();

            foreach (DMSType type in ModelResourcesDesc.TypeIdsInInsertOrder)
            {
                SortedDictionary <string, object> cimObjects = concreteModel.GetAllObjectsOfType("FTN." + ModelCodeHelper.DMSTypeToName(type));

                if (cimObjects == null)
                {
                    continue;
                }

                foreach (KeyValuePair <string, object> cimObjectPair in cimObjects)
                {
                    IDClass             idc = cimObjectPair.Value as IDClass;
                    long                gid = ModelCodeHelper.CreateGID(0, type, --counters[type]);
                    ResourceDescription rd  = new ResourceDescription(gid);
                    idMapping[idc.ID] = gid;
                    PopulateProperties(idc, rd);
                    delta.InsertOperations.Add(rd);
                }
            }

            return(delta);
        }
        public void CreateDelegate_Type(IDClass target)
        {
            int newId = 0;

            FieldInfo field = typeof(IDClass).GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance);
            DynamicMethod method = new DynamicMethod("Method", typeof(int), new Type[] { typeof(IDClass), typeof(int) }, typeof(IDClass));
            ILGenerator ilGenerator = method.GetILGenerator();
            Helpers.EmitMethodBody(ilGenerator, field);

            IDClassDelegate staticCallBack = (IDClassDelegate)method.CreateDelegate(typeof(IDClassDelegate));
            Assert.Equal(staticCallBack(target, newId), target.ID);
            Assert.Equal(newId, target.ID);
        }
        public void ILGenerator_Int_Type(bool skipVisibility)
        {
            IDClass target = new IDClass();
            FieldInfo field = typeof(IDClass).GetField(FieldName, BindingFlags.Instance | BindingFlags.NonPublic);

            Type[] paramTypes = new Type[] { typeof(IDClass), typeof(int) };
            DynamicMethod method = new DynamicMethod("Method", typeof(int), paramTypes, typeof(IDClass), skipVisibility);
            
            ILGenerator ilGenerator = method.GetILGenerator(8);
            Helpers.EmitMethodBody(ilGenerator, field);

            IntDelegate instanceCallBack = (IntDelegate)method.CreateDelegate(typeof(IntDelegate), target);
            VerifyILGenerator(instanceCallBack, target, 0);
        }
        public void CreateDelegate_Target_Module(IDClass target)
        {
            Module module = typeof(TestClass).GetTypeInfo().Module;
            int newId = 0;            

            FieldInfo field = typeof(IDClass).GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance);
            DynamicMethod method = new DynamicMethod("Method", typeof(int), new Type[] { typeof(IDClass), typeof(int) }, module, true);

            ILGenerator ilGenerator = method.GetILGenerator();
            Helpers.EmitMethodBody(ilGenerator, field);

            IntDelegate instanceCallBack = (IntDelegate)method.CreateDelegate(typeof(IntDelegate), target);
            Assert.Equal(instanceCallBack(newId), target.ID);
            Assert.Equal(newId, target.ID);
        }
        public void CreateDelegate_NoMethodBody_ThrowsInvalidOperationException()
        {
            IDClass target = new IDClass();
            DynamicMethod method = new DynamicMethod("Method", typeof(int), new Type[] { typeof(IDClass), typeof(int) }, typeof(IDClass));

            Assert.Throws<InvalidOperationException>(() => method.CreateDelegate(typeof(IntDelegate)));
            Assert.Throws<InvalidOperationException>(() => method.CreateDelegate(typeof(IntDelegate), target));
        }
 private void VerifyILGenerator(IntDelegate instanceCallBack, IDClass target, int newId)
 {
     Assert.Equal(instanceCallBack(newId), target.ID);
     Assert.Equal(newId, target.ID);
 }
        public void PopulateProperties(IDClass idc, ResourceDescription rd)
        {
            if (idc == null || rd == null)
            {
                return;
            }

            switch (ModelCodeHelper.GetTypeFromGID(rd.Id))
            {
            case DMSType.ACLineSegment:
                PopulateACLineSegmentProperties((ACLineSegment)idc, rd);
                break;

            case DMSType.Analog:
                PopulateAnalogProperties((Analog)idc, rd);
                break;

            case DMSType.BaseVoltage:
                PopulateBaseVoltageProperties((BaseVoltage)idc, rd);
                break;

            case DMSType.Breaker:
                PopulateBreakerProperties((Breaker)idc, rd);
                break;

            case DMSType.ConnectivityNode:
                PopulateConnectivityNodeProperties((ConnectivityNode)idc, rd);
                break;

            case DMSType.Disconnector:
                PopulateDisconnectorProperties((Disconnector)idc, rd);
                break;

            case DMSType.Discrete:
                PopulateDiscreteProperties((Discrete)idc, rd);
                break;

            case DMSType.DistributionGenerator:
                PopulateDistributionGeneratorProperties((DistributionGenerator)idc, rd);
                break;

            case DMSType.EnergyConsumer:
                PopulateEnergyConsumerProperties((EnergyConsumer)idc, rd);
                break;

            case DMSType.EnergySource:
                PopulateEnergySourceProperties((EnergySource)idc, rd);
                break;

            case DMSType.PowerTransformer:
                PopulatePowerTransformerProperties((PowerTransformer)idc, rd);
                break;

            case DMSType.RatioTapChanger:
                PopulateRatioTapChangerProperties((RatioTapChanger)idc, rd);
                break;

            case DMSType.Recloser:
                PopulateRecloserProperties((Recloser)idc, rd);
                break;

            case DMSType.Terminal:
                PopulateTerminalProperties((Terminal)idc, rd);
                break;

            case DMSType.TransformerWinding:
                PopulateTransformerWindingProperties((TransformerWinding)idc, rd);
                break;
            }
        }