Ejemplo n.º 1
0
        /// <summary>
        /// Bind a class to a specific convention
        /// </summary>
        /// <param name="classType">Type of the class to bind</param>
        /// <param name="convention">Convention with which the type has to be bound</param>
        /// <returns>void</returns>
        private void BindClassToConvention(Type classType, Convention convention)
        {
            if (classType == null || convention == null)
            {
                return;
            }

            List <string> a = (List <string>)_conventionList[convention];

            if (!a.Contains(classType.AssemblyQualifiedName))
            {
                a.Add(classType.AssemblyQualifiedName);
            }
        }
Ejemplo n.º 2
0
        // Comportamento particolare utilizzato per trovare le convenzioni in caso di chimate a metodi
        // (proprietà, campi pubbici) statici: se la convenzione non viene trovata per nome della classe
        // specificato si provano tutte le convenzioni caricate
        /// <summary>
        /// Find a convention bound to a specific class providing the name of the class
        /// </summary>
        /// <param name="className">Name of the class</param>
        /// <returns>Convention bound with the specified class or null if it doesn't exist</returns>
        private Convention FindConventionByClassName(string className)
        {
            Convention conv = null;

            foreach (Convention convention in _conventionList.Keys)
            {
                List <string> values = (List <string>)_conventionList[convention];
                foreach (Object o in values)
                {
                    if (o is string)
                    {
                        string t = (string)o;
                        if (t.Equals(className))
                        {
                            conv = convention;
                        }
                    }
                }
            }

            if (conv == null)
            {
                // Convention unknown, then try them all (the first that works)
                foreach (Convention convention in _conventionList.Keys)
                {
                    Type cl = convention.GetClass(className);

                    if (cl != null)
                    {
                        return(convention);
                    }
                }
            }

            return(conv);
        }
Ejemplo n.º 3
0
        private bool oo_get(Term objId, Term memberTerm, Term what)
        {
            what = what.getTerm();
            // If memberTerm is not an atom and what is a not instantiated variable
            if (!memberTerm.isAtom())
            {
                return(false);
            }

            string memberName = ((Struct)memberTerm).getName();

            // Object must be instantiated
            if (objId is Var)
            {
                return(false);
            }

            // Retrieving object instance
            object obj = this.getRegisteredDynamicObject((Struct)objId);

            if (obj != null)
            {
                // Instance property or field
                Convention conv = FindConvention(obj.GetType());

                if (conv != null)
                {
                    // Convention found
                    string revisedFieldName      = conv.GetFieldName(memberName);
                    string revisedPropertyMethod = conv.GetPropertyGetterMethod(memberName);

                    FieldInfo  field  = obj.GetType().GetField(revisedFieldName);
                    MethodInfo method = obj.GetType().GetMethod(revisedPropertyMethod);

                    if (field != null && method == null)
                    {
                        // Field
                        Struct filedStruct = new Struct(revisedFieldName);
                        Struct objStruct   = new Struct(".", objId, filedStruct);
                        Var    objVar      = new Var();
                        this.unify(objVar, objStruct);

                        Struct methodStruct = new Struct("get", what);
                        Var    methodVar    = new Var();
                        this.unify(methodVar, methodStruct);

                        return(base.java_call_3(objVar, methodVar, new Struct()));
                    }
                    else if (field == null && method != null)
                    {
                        // Property
                        Struct methodStruct = new Struct(revisedPropertyMethod);
                        return(base.java_call_3(objId, methodStruct, what));
                    }
                }
                else
                {
                    // Convention NOT found
                    FieldInfo  field  = obj.GetType().GetField(memberName);
                    MethodInfo method = obj.GetType().GetMethod(memberName);

                    if (field != null && method == null)
                    {
                        // Field
                        Struct fieldStruct = new Struct(memberName);
                        Struct objStruct   = new Struct(".", objId, fieldStruct);
                        Var    objVar      = new Var();
                        this.unify(objVar, objStruct);

                        Struct methodStruct = new Struct("get", what);
                        Var    methodVar    = new Var();
                        this.unify(methodVar, methodStruct);

                        return(base.java_call_3(objVar, methodVar, new Struct()));
                    }
                    else if (field == null && method != null)
                    {
                        // Property
                        Struct methodStruct = new Struct(memberName);
                        return(base.java_call_3(objId, methodStruct, what));
                    }
                }
            }
            else
            {
                // Could be a static invocation

                if (objId.isCompound())
                {
                    Struct objIdStruct = (Struct)objId;
                    if (objIdStruct.getArity() == 1 && objIdStruct.getName().Equals("class"))
                    {
                        // Static property or field
                        string     className = RemoveApices(objIdStruct.getArg(0).ToString());
                        Convention conv      = FindConventionByClassName(className);

                        if (conv != null)
                        {
                            // Convention found
                            string revisedClassname      = conv.GetClassName(className);
                            Type   classType             = Type.GetType(revisedClassname);
                            string revisedFieldName      = conv.GetFieldName(memberName);
                            string revisedPropertyMethod = conv.GetPropertyGetterMethod(memberName);

                            FieldInfo  field  = classType.GetField(revisedFieldName);
                            MethodInfo method = classType.GetMethod(revisedPropertyMethod);

                            if (field != null && method == null)
                            {
                                // Field
                                Struct fieldStruct     = new Struct(revisedFieldName);
                                Struct classNameStruct = new Struct(revisedClassname);
                                Struct classStruct     = new Struct("class", classNameStruct);
                                Struct st       = new Struct(".", classStruct, fieldStruct);
                                Var    classVar = new Var();
                                this.unify(classVar, st);

                                Struct methodStruct = new Struct("get", what);
                                Var    methodVar    = new Var();
                                this.unify(methodVar, methodStruct);

                                return(base.java_call_3(classVar, methodVar, new Struct()));
                            }
                            else if (field == null && method != null)
                            {
                                // Property
                                Struct classNameStruct = new Struct(revisedClassname);
                                Struct classStruct     = new Struct("class", classNameStruct);
                                Var    classVar        = new Var();
                                this.unify(classVar, classStruct);

                                Struct staticMethod    = new Struct(revisedPropertyMethod);
                                Var    staticMethodVar = new Var();
                                this.unify(staticMethodVar, staticMethod);

                                return(base.java_call_3(classVar, staticMethodVar, what));
                            }
                        }
                        else
                        {
                            // Convention NOT found
                            Type       classType = Type.GetType(className);
                            FieldInfo  field     = classType.GetField(memberName);
                            MethodInfo method    = classType.GetMethod(memberName);

                            if (field != null && method == null)
                            {
                                // Field
                                Struct fieldStruct     = new Struct(memberName);
                                Struct classNameStruct = new Struct(className);
                                Struct classStruct     = new Struct("class", classNameStruct);
                                Struct st       = new Struct(".", classStruct, fieldStruct);
                                Var    classVar = new Var();
                                this.unify(classVar, st);

                                Struct methodStruct = new Struct("get", what);
                                Var    methodVar    = new Var();
                                this.unify(methodVar, methodStruct);

                                return(base.java_call_3(classVar, methodVar, new Struct()));
                            }
                            else if (field == null && method != null)
                            {
                                // Property
                                Struct classNameStruct = new Struct(className);
                                Struct classStruct     = new Struct("class", classNameStruct);
                                Var    classVar        = new Var();
                                this.unify(classVar, classStruct);

                                Struct staticMethod    = new Struct(memberName);
                                Var    staticMethodVar = new Var();
                                this.unify(staticMethodVar, staticMethod);

                                return(base.java_call_3(classVar, staticMethodVar, what));
                            }
                        }
                    }
                }
            }

            return(false);
        }
Ejemplo n.º 4
0
        // In the following three methods is possible to factorize the code
        // Check this!!!
        public bool method_call_3(Term objId, Term method_name, Term idResult)
        {
            Struct objIdTerm        = (Struct)objId.getTerm();
            Struct methodNameStruct = (Struct)method_name.getTerm();
            string methodName       = methodNameStruct.getName();

            // check for accessing field or property  Obj.Field <- set/get(X)
            // in that case: objId is '.'(Obj, Field)
            if (!objIdTerm.isAtom())
            {
                if (objIdTerm is Var)
                {
                    return(false);
                }

                Struct objIdStruct = (Struct)objIdTerm;
                if (objIdStruct.getName().Equals(".") && objIdStruct.getArity() == 2 && methodNameStruct.getArity() == 1)
                {
                    if (methodName.Equals("set"))
                    {
                        return(oo_set(objIdStruct.getTerm(0), objIdStruct.getTerm(1), methodNameStruct.getTerm(0)));
                    }
                    else if (methodName.Equals("get"))
                    {
                        return(oo_get(objIdStruct.getTerm(0), objIdStruct.getTerm(1), methodNameStruct.getTerm(0)));
                    }
                }
            }

            // Object must be instantiated
            if (objIdTerm is Var)
            {
                return(false);
            }

            // Retrieving object instance
            object obj = this.getRegisteredDynamicObject((Struct)objIdTerm);

            if (obj != null)
            {
                // Instance method

                Convention conv = FindConvention(obj.GetType());

                if (conv != null)
                {
                    // Convention found
                    string revisedMethodName = conv.GetMemberName(methodName);
                    Struct methodStruct      = new Struct(revisedMethodName, getArrayFromMethod(methodNameStruct));
                    return(base.java_call_3(objId, methodStruct, idResult));
                }
                else
                {
                    // Convention NOT found
                    return(base.java_call_3(objId, method_name, idResult));
                }
            }
            else
            {
                // Object not found: could be a static call

                if (objId.isCompound())
                {
                    if (objIdTerm.getArity() == 1 && objIdTerm.getName().Equals("class"))
                    {
                        // Static method
                        string     className = RemoveApices(objIdTerm.getArg(0).ToString());
                        Convention conv      = FindConventionByClassName(className);

                        if (conv != null)
                        {
                            // Convention found
                            string revisedClassName  = conv.GetClassName(className);
                            string revisedMethodName = conv.GetMemberName(methodName);

                            Struct classNameStruct = new Struct(revisedClassName);
                            Struct classStruct     = new Struct("class", classNameStruct);
                            Var    classVar        = new Var();
                            this.unify(classVar, classStruct);

                            Struct staticMethod    = new Struct(revisedMethodName, getArrayFromMethod(methodNameStruct));
                            Var    staticMethodVar = new Var();
                            this.unify(staticMethodVar, staticMethod);

                            return(base.java_call_3(classVar, staticMethodVar, idResult));
                        }
                        else
                        {
                            // Convention NOT found
                            return(base.java_call_3(objId, method_name, idResult));
                        }
                    }
                }
            }

            return(false);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Creates of a .NET object from an assembly - not backtrackable case
        /// </summary>
        /// <param name="conventionName">Name of the convention to bind with the object</param>
        /// <param name="className">Name of the class with namespace informations</param>
        /// <param name="constructorName">Name of the constructor used to instantiate the class</param>
        /// <param name="argl">List of arguments for the constructor</param>
        /// <param name="id">Reference to the instantiated object (out)</param>
        /// <returns>True if the operation is successful</returns>
        public bool new_object_5(Term conventionName, Term className, Term constructorName, Term argl, Term id)
        {
            className = className.getTerm();
            Struct arg = (Struct)argl.getTerm();

            id = id.getTerm();

            // Class name must be a simple atom
            if (!className.isAtom())
            {
                return(false);
            }

            string clName = ((Struct)className).getName();

            // Retrieving Convention name if present
            string convName = null;

            if (conventionName != null && (conventionName.getTerm() is Struct))
            {
                convName = ((Struct)conventionName.getTerm()).getName();
            }

            // Retrieving Constructor name if present
            string constrName = null;

            if (constructorName != null && (constructorName.getTerm() is Struct))
            {
                constrName = ((Struct)constructorName.getTerm()).getName();
            }

            Convention conv = FindConvention(convName);

            if (conv != null)
            {
                // Convention found

                Struct revisedClassNameStruct = null;
                string revisedClassName       = conv.GetClassName(clName);
                revisedClassNameStruct = new Struct(revisedClassName);

                if (conv.IsArrayClass(revisedClassName))
                {
                    // Construction of an array
                    string arrayClassName = revisedClassName.Substring(0, revisedClassName.Length - 2);
                    arrayClassName         = arrayClassName + "[]";
                    revisedClassNameStruct = new Struct(arrayClassName);
                }

                if (constrName != null && !constrName.Equals(String.Empty))
                {
                    // If it is specified the static method that build the object, I have to call it
                    string revisedConstrName = conv.GetConstructorName(constrName);
                    string constrClassName   = conv.GetConstructorClass(revisedClassName);
                    Struct constrNameStruct  = new Struct(constrClassName);
                    Struct constr            = new Struct("class", constrNameStruct);
                    Var    constrClass       = new Var();
                    this.unify(constrClass, constr);

                    Struct constrMethod     = new Struct(revisedConstrName, getArrayFromList(arg));
                    Var    constrMethodName = new Var();
                    this.unify(constrMethodName, constrMethod);

                    return(base.java_call_3(constrClass, constrMethodName, id));
                }

                // Call the super class method after the modification of the names
                bool returnValue = base.java_object_3(revisedClassNameStruct, argl, id);

                // If everything went fine, the type has been loaded correctly by the JavaLibrary class loader
                // therefore we can bind the type to the convention
                if (returnValue)
                {
                    Type classType = Type.GetType(revisedClassName);

                    if (!IsBoundToConvention(classType))
                    {
                        // The class is not link to the convention: link it!
                        BindClassToConvention(classType, conv);
                    }
                }

                return(returnValue);
            }
            else
            {
                // Convention NOT found
                // For arrays nothing to do: I guess that the user used []

                if (constrName != null && !constrName.Equals(String.Empty))
                {
                    // If it is specified the static method that build the object, I have to call it
                    // but this time without convention
                    Struct constrNameStruct = new Struct(clName);
                    Struct constr           = new Struct("class", constrNameStruct);
                    Var    constrClass      = new Var();
                    this.unify(constrClass, constr);

                    Struct constrMethod     = new Struct(constrName, getArrayFromList(arg));
                    Var    constrMethodName = new Var();
                    this.unify(constrMethodName, constrMethod);

                    return(base.java_call_3(constrClass, constrMethodName, id));
                }
            }

            // No modifications
            return(base.java_object_3(className, argl, id));
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Load a convention by its assembly and classname
        /// </summary>
        /// <param name="assemblyName">Assembly file that contains the convention</param>
        /// <param name="conventionName">Class name of the convention</param>
        /// <param name="id">Identifier of the convention</param>
        /// <returns>True if the operation is successful</returns>
        public bool load_convention_3(Term assemblyName, Term conventionName, Term id)
        {
            Struct convName = (Struct)conventionName.getTerm();
            Struct asName   = (Struct)assemblyName.getTerm();

            if (convName == null || !convName.isAtom() || asName == null || !asName.isAtom() || (!(id is Var) && !id.isAtom()))
            {
                return(false);
            }

            try
            {
                Convention newConv        = Convention.LoadConvention(asName.getName(), convName.getName());
                Convention alreadyPresent = FindConvention(newConv.Name);

                // Convention not loaded
                if (alreadyPresent == null)
                {
                    _conventionList.Add(newConv, new List <string>());

                    // Id is an atom or a variable bound to an atom
                    if (id.isAtom() || id.getTerm().isAtom())
                    {
                        // Check if the id specified is already in use
                        if (this.getRegisteredObject((Struct)id) == null)
                        {
                            return(this.bindDynamicObject(id.getTerm(), newConv));
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else if (id is Var)
                    {
                        // Id set to Convention.Name and unified with the variable
                        Struct newId = new Struct(newConv.Name);
                        return((this.bindDynamicObject(newId, newConv)) && (this.unify(id, newId)));
                    }
                }
                else
                {
                    // Convention already loaded
                    if (id.isAtom() || id.getTerm().isAtom())
                    {
                        string key  = RemoveApices(id.getTerm().ToString());
                        object conv = this.getRegisteredDynamicObject((Struct)id);
                        if (conv != null && conv is Convention)
                        {
                            Convention found = (Convention)conv;
                            // If convention found in objects and in conventions lists are equals, ok!
                            if (found.Name.Equals(alreadyPresent.Name))
                            {
                                return(true);
                            }
                            else
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        // TO CHECK -----------------------------------------------------
                        // If id is var then find the atom identifier and bind to id

                        // Here the Convention is already loaded so (in theory) the following call will return the identifier
                        // without register the Convention another time, however this call could be unsafe
                        Struct oldId = this.registerDynamic(alreadyPresent);
                        return(this.unify(id, oldId));

                        #region Albertin Code
                        //if (_currentObjects_inverse.Contains(alreadyPresent))
                        //    return Unify(id, (Struct)_currentObjects_inverse[alreadyPresent]);
                        //else
                        //    return false;
                        #endregion
                    }
                }

                return(false);
            }
            catch (Exception ex)
            {
                return(false);
            }
        }