/// <summary>
        /// Checks relations.
        /// </summary>
        /// <param name="lObjectInterface">ObjectInterface.</param>
        /// <param name="NextElement">Next element we are going to parse.</param>
        /// <param name="CallCalback">Do we have to call callback?</param>
        /// <returns>FunctionIO with return parameters like ret value and parse count.</returns>
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            ObjectAttributeEvaluation Evaluation = GetEvaluation();

            bool result = false;
            List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
            for (int x = 0; x < SubPrimitives.Count; x++)
            {
                FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], CallCalback);
                if (ret["RetVal"].Value)
                {
                    result = true;
                    Evaluation.Evaluate((ObjectAttributeEvaluation)ret["ParseCount"]);

                    break;//Proper logic is to break if parser primitives relations are correct,
                    //other logic is to select parser primitive where ParseCount is the biggest.
                    //we use proper logic.
                }
            }

            if (result)
                return new FunctionIO(Evaluation, RetVal.True);

            return new FunctionIO(RetVal.False);
        }
Ejemplo n.º 2
0
 public void moreps(ObjectInterfacePrototipe lObjectInterface)
 {
     called = true;
 }
        /// <summary>
        /// Checks relations.
        /// </summary>
        /// <param name="lObjectInterface">ObjectInterface.</param>
        /// <param name="NextElement">Next element we are going to parse.</param>
        /// <param name="CallCalback">Do we have to call callback?</param>
        /// <returns>FunctionIO with return parameters like ret value and parse count.</returns>
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            ObjectAttributeEvaluation Evaluation = GetEvaluation();

            bool More = true;
            int TotalMove = 0;
            int StartOffset = lObjectInterface.GetOffset();
            bool eof = false;

            while (More)
            {
                int Positives = 0;
                int CurrentMove = 0;

                if (NextElement != null)
                {
                    FunctionIO ret = NextElement.CheckRelations(ref lObjectInterface, NextElement.GetNextPrimitive(), false);
                    if (ret["RetVal"].Value)
                        break;
                }

                int RecallOffset = lObjectInterface.GetOffset();
                List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
                for (int x = 0; x < SubPrimitives.Count; x++)
                {
                    CurrentMove = 0;

                    FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], false);
                    if (ret["RetVal"].Value)
                    {
                        CurrentMove = ((ObjectAttributeEvaluation)ret["ParseCount"]).Value;
                        Positives++;
                    }
                    else//End execution if we fail
                        break;
                    eof = lObjectInterface.MoveByOffset(CurrentMove);

                    TotalMove += CurrentMove;

                    if (eof)
                        break;
                }

                if (CallCalback && Positives == SubPrimitives.Count)
                {
                    lObjectInterface.SetOffset(RecallOffset);
                    for (int x = 0; x < SubPrimitives.Count; x++)
                    {
                        CurrentMove = 0;

                        FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], CallCalback);
                        CurrentMove = ((ObjectAttributeEvaluation)ret["ParseCount"]).Value;

                        eof = lObjectInterface.MoveByOffset(CurrentMove);
                    }
                }

                if (eof || Positives != SubPrimitives.Count)
                {
                    break;
                }
            }

            if (!Evaluation.Evaluate(TotalMove))
                return new FunctionIO(RetVal.False);

            lObjectInterface.SetOffset(StartOffset);

            return new FunctionIO(Evaluation, RetVal.True);
        }
Ejemplo n.º 4
0
 public bool Preheader2(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
Ejemplo n.º 5
0
 public bool Call(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
Ejemplo n.º 6
0
            public bool NewTable(ObjectInterfacePrototipe lObjectInterface)
            {
                ObjectAttributeString lObjectAttribute = (ObjectAttributeString)lObjectInterface.GetCurrentObject().GetAttributeByName("outerHTML");
                ExtractedTables.Add(lObjectAttribute.Value);

                return true;
            }
Ejemplo n.º 7
0
 public bool Postheader2Description(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
 public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
 {
     FunctionIO ret= cRelationFunction.CheckRelations(ref lObjectInterface, NextElement, CallCalback);
     if (((ObjectAttributeInt)ret.GetFunctionParameterByName("ret")).GetAttributeValue() == 1)
         if (cCallback != null && CallCalback)
             cCallback(lObjectInterface);
     return ret;
 }
 public virtual FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
 {
     return null;
 }
Ejemplo n.º 10
0
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            FunctionIO ReturnContainer= new FunctionIO();
            ObjectAttributeInt ReturnValue1 = new ObjectAttributeInt("ret",1);
            ObjectAttributeInt ReturnValue0 = new ObjectAttributeInt("ret",0);
            ObjectAttributeEvaluation Evaluation =  new ObjectAttributeEvaluation();
            Evaluation.SetAttributeName("ParseCount");

            if (!CheckCurrentObject(ref lObjectInterface))
            {
                ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue0);
                return ReturnContainer;
            }

            if (cParserPrimitives.Count == 0)
            {
                if (cCallback != null && CallCalback)
                    cCallback(lObjectInterface);

                ReturnContainer.AddFunctionParameter((ObjectAttribute)Evaluation);
                ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue1);
                return ReturnContainer;
            }

            //Here we preset next primitives
            for (int x = 0; x < cParserPrimitives.Count-1; x++)
            {
                cParserPrimitives[x].SetNextPrimitive(cParserPrimitives[x + 1]);
            }

            ObjectInterfacePrototipe SubObjects= lObjectInterface.GetSubObjects();
            SubObjects.GetFirstObject();
            ObjectAttributeEvaluation ParseCountEvaluation = new ObjectAttributeEvaluation( EvaluationMode.Max, 1, 100000000);
            for( int x=0; x< cParserPrimitives.Count; x++ )
            {
                ParserPrimitives tPrimitives;
                if (cParserPrimitives.Count == x + 1)
                    tPrimitives = null;
                else
                    tPrimitives = cParserPrimitives[x + 1];
                FunctionIO ret = cParserPrimitives[x].CheckRelations(ref SubObjects, tPrimitives, CallCalback);
                if (((ObjectAttributeInt)ret.GetFunctionParameterByName("ret")).GetAttributeValue() != 1)
                {
                    ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue0);
                    return ReturnContainer;
                }

                SubObjects.GetOffsetObject(((ObjectAttributeEvaluation)ret.GetFunctionParameterByName("ParseCount")).GetEvaluationValue());
            }

            if (cCallback != null && CallCalback)
                cCallback(lObjectInterface);

            ReturnContainer.AddFunctionParameter((ObjectAttribute)Evaluation);
            ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue1);
            return ReturnContainer;
        }
Ejemplo n.º 11
0
        //Singleton check
        bool CheckCurrentObject(ref ObjectInterfacePrototipe lObjectInterface)
        {
            ObjectPrototipe lObjectPrototipe= lObjectInterface.GetCurrentObject();

            if (GetAttributeByName("name") != null)
            {
                ObjectAttributeString lObjectAttributeString = new ObjectAttributeString();
                lObjectAttributeString.SetAttributeName("name");
                lObjectAttributeString.SetAttributeValue(lObjectPrototipe.GetObjectName());
                if (!GetAttributeByName("name").ComapreAttributes((ObjectAttribute)lObjectAttributeString))
                    return false;
            }

            foreach (ObjectAttribute lObjectAttribute in cObjectAttributes)
            {
                if (lObjectAttribute.GetAttributeName() == "name")
                    continue;
                if(!lObjectAttribute.ComapreAttributes(lObjectPrototipe.GetAttributeByName(lObjectAttribute.GetAttributeName())))
                    return false;
            }

            return true;
        }
Ejemplo n.º 12
0
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            FunctionIO ret= cRelationFunction.CheckRelations(ref lObjectInterface, NextElement, CallCalback);
            ObjectAttribute RetVal=ret["RetVal"];
            if (RetVal.Value)
            {
                if (cCallback != null && CallCalback)
                {
                    if (!cCallback(lObjectInterface))
                    {
                        RetVal.Value = false;
                    }
                }
            }

            return ret;
        }
Ejemplo n.º 13
0
        //Singleton check
        bool CheckCurrentObject(ref ObjectInterfacePrototipe lObjectInterface)
        {
            ObjectPrototipe lObjectPrototipe= lObjectInterface.GetCurrentObject();

            if (GetAttributeByName("name") != null)
            {
                ObjectAttributeString lObjectAttributeString = new ObjectAttributeString("name", lObjectPrototipe.GetObjectName());
                if (GetAttributeByName("name")!=lObjectAttributeString)
                    return false;
            }

            foreach (ObjectAttribute lObjectAttribute in (from n in cObjectAttributes where n.AttributeName!="name" && n.AttributeName!="negation" select n))
            {
                if(lObjectAttribute!=lObjectPrototipe.GetAttributeByName(lObjectAttribute.AttributeName))
                    return false;
            }

            return true;
        }
Ejemplo n.º 14
0
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            ObjectAttributeEvaluation Evaluation =  new ObjectAttributeEvaluation();
            Evaluation.AttributeName="ParseCount";
            bool negation = GetAttributeByName("negation")==null? false: true;

            bool Result = CheckCurrentObject(ref lObjectInterface);
            if (negation)
            {
                if (Result)
                    return new FunctionIO(RetVal.False);
            }
            else
            {
                if (!Result)
                    return new FunctionIO(RetVal.False);
            }

            if (cParserPrimitives.Count == 0)
            {
                if (cCallback != null && CallCalback)
                    if (!cCallback(lObjectInterface))
                        return new FunctionIO(Evaluation, RetVal.False);

                return new FunctionIO(Evaluation, RetVal.True);
            }

            //Here we preset next primitives
            for (int x = 0; x < cParserPrimitives.Count-1; x++)
                cParserPrimitives[x].SetNextPrimitive(cParserPrimitives[x + 1]);

            ObjectInterfacePrototipe SubObjects= lObjectInterface.GetSubObjects();
            if (SubObjects.GetFirstObject() == null)
                return new FunctionIO(Evaluation, RetVal.True);

            ObjectAttributeEvaluation ParseCountEvaluation = new ObjectAttributeEvaluation( EvaluationMode.Max, 1, int.MaxValue);
            for( int x=0; x< cParserPrimitives.Count; x++ )
            {
                ParserPrimitives tPrimitives;
                if (cParserPrimitives.Count == x + 1)
                    tPrimitives = null;
                else
                    tPrimitives = cParserPrimitives[x + 1];
                FunctionIO ret = cParserPrimitives[x].CheckRelations(ref SubObjects, tPrimitives, CallCalback);
                bool tResult= ret["RetVal"].Value;

                if (!negation)
                    if (!tResult)
                        return new FunctionIO(RetVal.False);
                else
                    if (tResult)
                        return new FunctionIO(RetVal.False);

                SubObjects.GetOffsetObject(ret["ParseCount"].Value);
            }

            if (cCallback != null && CallCalback)
                cCallback(lObjectInterface);

            return new FunctionIO(Evaluation, RetVal.True);
        }
Ejemplo n.º 15
0
 public bool NewBitfieldDescriptionField(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
Ejemplo n.º 16
0
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            FunctionIO ReturnContainer = new FunctionIO();
            ObjectAttributeInt ReturnValue1 = new ObjectAttributeInt("ret", 1);
            ObjectAttributeInt ReturnValue0 = new ObjectAttributeInt("ret", 0);
            ObjectAttributeEvaluation Evaluation = null;
            if (cFunctionParameters == null || cFunctionParameters.GetFunctionParameterByName("ParseCount") == null)
            {
                Evaluation = new ObjectAttributeEvaluation();
                Evaluation.SetAttributeName("ParseCount");
            }
            else
                Evaluation = (ObjectAttributeEvaluation)cFunctionParameters.GetFunctionParameterByName("ParseCount");

            bool More = true;
            int TotalMove= 0;
            int StartOffset = lObjectInterface.GetOffset();
            bool eof = false;

            while (More)
            {
                int Positives = 0;
                int CurrentMove = 0;

                if (NextElement != null)
                {
                    FunctionIO ret = NextElement.CheckRelations(ref lObjectInterface, NextElement.GetNextPrimitive(), false);
                    if (((ObjectAttributeInt)ret.GetFunctionParameterByName("ret")).GetAttributeValue() == 1)
                    {
                        break;
                    }
                }

                List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
                for (int x = 0; x < SubPrimitives.Count; x++)
                {
                    ParserPrimitives tPrimitives;
                    if (SubPrimitives.Count == x + 1)
                        tPrimitives = null;
                    else
                        tPrimitives = SubPrimitives[x + 1];
                    FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, tPrimitives, CallCalback);
                    if (((ObjectAttributeInt)ret.GetFunctionParameterByName("ret")).GetAttributeValue() == 1)
                    {
                        CurrentMove += ((ObjectAttributeEvaluation)ret.GetFunctionParameterByName("ParseCount")).GetEvaluationValue();
                        Positives++;
                    }
                    eof=lObjectInterface.MoveByOffset(CurrentMove);
                }

                TotalMove += CurrentMove;

                if (Positives != SubPrimitives.Count || eof)
                {
                    More = false;
                }
            }

            if (!Evaluation.EvaluateNext(TotalMove))
            {
                ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue0);
                return ReturnContainer;
            }

            lObjectInterface.SetOffset(StartOffset);

            ReturnContainer.AddFunctionParameter(Evaluation);
            ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue1);
            return ReturnContainer;
        }
Ejemplo n.º 17
0
 public bool NewBlankBitfield(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
Ejemplo n.º 18
0
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            FunctionIO ReturnContainer = new FunctionIO();
            ObjectAttributeInt ReturnValue1 = new ObjectAttributeInt("ret", 1);
            ObjectAttributeInt ReturnValue0 = new ObjectAttributeInt("ret", 0);
            ObjectAttributeEvaluation Evaluation= null;
            if (cFunctionParameters == null || cFunctionParameters.GetFunctionParameterByName("ParseCount") == null)
            {
                Evaluation = new ObjectAttributeEvaluation();
                Evaluation.SetAttributeName("ParseCount");
            }
            else
                Evaluation = (ObjectAttributeEvaluation)cFunctionParameters.GetFunctionParameterByName("ParseCount");

            bool result = false;
            List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
            for (int x = 0; x < SubPrimitives.Count; x++)
            {
                ParserPrimitives tPrimitives;
                if (SubPrimitives.Count == x + 1)
                    tPrimitives = null;
                else
                    tPrimitives = SubPrimitives[x + 1];
                FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, tPrimitives,CallCalback);
                if (((ObjectAttributeInt)ret.GetFunctionParameterByName("ret")).GetAttributeValue() == 1)
                {
                    result = true;
                    Evaluation.SubEvaluate((ObjectAttributeEvaluation)ret.GetFunctionParameterByName("ParseCount"));
                }
            }

            if (result)
            {
                ReturnContainer.AddFunctionParameter((ObjectAttribute)Evaluation);
                ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue1);
                return ReturnContainer;
            }

            ReturnContainer.AddFunctionParameter((ObjectAttribute)ReturnValue0);
            return ReturnContainer;
        }
Ejemplo n.º 19
0
 public bool Postheader1Element(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
        /// <summary>
        /// Checks relations.
        /// </summary>
        /// <param name="lObjectInterface">ObjectInterface.</param>
        /// <param name="NextElement">Next element we are going to parse.</param>
        /// <param name="CallCalback">Do we have to call callback?</param>
        /// <returns>FunctionIO with return parameters like ret value and parse count.</returns>
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            ObjectAttributeEvaluation Evaluation = GetEvaluation();

            int Positives = 0;
            List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
            for (int x = 0; x < SubPrimitives.Count; x++)
            {
                FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], CallCalback);
                if (ret["RetVal"].Value)
                {
                    Positives++;
                    if (!Evaluation.Evaluate((ObjectAttributeEvaluation)ret["ParseCount"]))
                        return new FunctionIO(RetVal.False);
                }
            }

            if (Positives == SubPrimitives.Count)
                return new FunctionIO(Evaluation, RetVal.True);

            return new FunctionIO(RetVal.False);
        }
Ejemplo n.º 21
0
 public bool Postheader2Name(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
        /// <summary>
        /// Recursively check all depths.
        /// </summary>
        /// <param name="lObjectInterface">ObjectInterface.</param>
        /// <param name="CallCallback">Do we have to call callback?</param>
        /// <param name="depth">Current depth.</param>
        /// <returns>FunctionIO with return parameters like ret value and parse count.</returns>
        public FunctionIO CheckDeepRelations(ref ObjectInterfacePrototipe lObjectInterface, bool CallCallback, int depth)
        {
            ObjectAttributeEvaluation Evaluation = new ObjectAttributeEvaluation();
            Evaluation.AttributeName = "ParseCount";

            if (depth > MaxDepth)
                return new FunctionIO(RetVal.False);

            bool More = true;
            int TotalMove = 0;
            int OccurenciesFound = 0;
            int StartOffset = lObjectInterface.GetOffset();
            bool eof = false;

            List<ParserPrimitives> SubPrimitives = cParserObjectRelation.GetSubParserPrimitives();
            while (More)
            {
                int CurrentMove = 0;
                int Positives = 0;

                ObjectInterfacePrototipe tInterface = lObjectInterface.GetSubObjects();
                FunctionIO ret2 = null;
                if (tInterface != null)
                {
                    tInterface.GetFirstObject();
                    if (tInterface.GetCurrentObject() != null)
                    {
                        ret2 = CheckDeepRelations(ref tInterface, CallCallback, depth + 1);
                        if (ret2["RetVal"].Value)
                            OccurenciesFound += ret2["Occurencies"].Value;
                    }
                }

                for (int x = 0; x < SubPrimitives.Count; x++)
                {
                    CurrentMove = 0;

                    FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], false);
                    if (ret["RetVal"].Value)
                    {
                        CurrentMove = ((ObjectAttributeEvaluation)ret["ParseCount"]).Value;
                        Positives++;
                    }
                    else
                        break;//Stop execution if we fail.
                    eof = lObjectInterface.MoveByOffset(CurrentMove);

                    if (eof)
                        break;
                }

                //if (eof)
                //    break;

                lObjectInterface.SetOffset(StartOffset);//We go back to start offset
                eof = lObjectInterface.MoveByOffset(TotalMove);//and move for one step and continue checking from there
                if (Positives == SubPrimitives.Count)
                {
                    OccurenciesFound++;//We find a new occurency and incrise counter
                    //We recall our callbacks
                    if (CallCallback)
                    {
                        for (int x = 0; x < SubPrimitives.Count; x++)
                        {
                            CurrentMove = 0;

                            FunctionIO ret = SubPrimitives[x].CheckRelations(ref lObjectInterface, x + 1 == SubPrimitives.Count ? null : SubPrimitives[x + 1], CallCallback);
                            CurrentMove = ((ObjectAttributeEvaluation)ret["ParseCount"]).Value;
                            eof = lObjectInterface.MoveByOffset(CurrentMove);
                        }
                    }
                }

                TotalMove++;//We incrise move
                lObjectInterface.SetOffset(StartOffset);//We go back to start offset
                eof = lObjectInterface.MoveByOffset(TotalMove);//and move for one step and continue checking from there

                if (eof)
                    break;
            }

            if (OccurenciesFound == 0)
                return new FunctionIO(RetVal.False);

            Evaluation.Evaluate(TotalMove);

            lObjectInterface.SetOffset(StartOffset);

            ObjectAttributeInt ParamOccurrenciesFound = new ObjectAttributeInt("Occurencies", OccurenciesFound);

            return new FunctionIO(ParamOccurrenciesFound, Evaluation, RetVal.False);
        }
Ejemplo n.º 23
0
 public bool Preheader2Element(ObjectInterfacePrototipe lObjectInterface)
 {
     if (lObjectInterface.GetObjectCount() < 32)
         return false;
     return true;
 }
        /// <summary>
        /// Checks relations.
        /// </summary>
        /// <param name="lObjectInterface">ObjectInterface.</param>
        /// <param name="NextElement">Next element we are going to parse.</param>
        /// <param name="CallCalback">Do we have to call callback?</param>
        /// <returns>FunctionIO with return parameters like ret value and parse count.</returns>
        public override FunctionIO CheckRelations(ref ObjectInterfacePrototipe lObjectInterface, ParserPrimitives NextElement, bool CallCalback)
        {
            ObjectAttribute lMaxDepth = null;
            if (cFunctionParameters != null && (lMaxDepth = cFunctionParameters["MaxDepth"]) != null)
                MaxDepth = lMaxDepth.Value;

            FunctionIO ret = CheckDeepRelations(ref lObjectInterface, CallCalback, 1);
            if (!ret["RetVal"].Value)
                return new FunctionIO(RetVal.False);

            int occurencies = ret["Occurencies"].Value;
            ObjectAttribute MinOccurencies;
            ObjectAttribute MaxOccurencies;
            if (cFunctionParameters != null && (MinOccurencies = cFunctionParameters["MinOccurencies"]) != null && (MaxOccurencies = cFunctionParameters["MaxOccurencies"]) != null)
                if (occurencies < MinOccurencies.Value || occurencies > MaxOccurencies.Value)
                    return new FunctionIO(RetVal.False);

            return ret;
        }
Ejemplo n.º 25
0
 public bool moretables(ObjectInterfacePrototipe lObjectInterface)
 {
     return true;
 }
Ejemplo n.º 26
0
 public void Call(ObjectInterfacePrototipe lObjectInterface)
 {
     called = true;
 }