Exemple #1
0
def parse_element_to_packet(fp, k, v):
    if is_inner_type(v) == True:
        fp.write("        packet << " + k + ";\n")
    elif util.is_list(v) and len(v) == 1: #vector
        fp.write("        packet << (uint32)" + k + ".size();\n")
        fp.write("        for(int i = 0; i < " + k + ".size(); i++)\n")
        fp.write("        {\n")
        if is_inner_type(v[0]) == True:
            fp.write("            packet << " + k + "[i];\n")
        else:
            fp.write("            " + k + ".ToPacket(packet);\n")
        fp.write("        }\n")
    elif util.is_list(v) and len(v) == 2: #map
        fp.write("        packet << (uint32)" + k + ".size();\n")
        fp.write("        std::map<" + v[0] + "," + v[1] + ">::iterator it = " + k + ".begin; it != " + k + ".end(); it++)\n")
        fp.write("        {\n")
        if is_inner_type(v[0]) == True:
            #内置对象
            fp.write("            packet << it->first;\n")
        else:
            #自定义对象
            fp.write("            it->first.ToPacket(packet);\n")

        if is_inner_type(v[1]) == True:
            #内置对象
            fp.write("            packet << it->second;\n")
        else:
            #自定义对象
            fp.write("            it->second.ToPacket(packet);\n")
        fp.write("        }\n")
    else:
        fp.write("        " + k + ".ToPacket(packet);\n")
Exemple #2
0
def generate_struct(fp,str,struct_name):
    head_str = "struct" + " " + struct_name + " {\n"
    fp.write(head_str)

    if type(str) != type([]):
        print "generate_struct str is not list"
        return

    for i in range(0,len(str)):
        element = str[i]
        key = element[0]
        value = element[1]

        #   组装字段类型
        if util.is_string(value) and is_inner_type(value):
            # 内部数据
            element_str = "    " + value + " " + key + ";\n"
        elif util.is_list(value) and len(value) == 1:
            # 如果为元组 则为vector
            element_str = "    " + "std::vector<" + value[0] + "> " + key + ";\n"
        elif util.is_list(value) and len(value) == 2:
            # 如果为元组 两个元素则为map
            element_str = "    " + "std::map<" + value[0] + "," + value[1] + "> " + key + ";\n"
        fp.write(element_str)
        #   组装ToPacket和FromPacket
    fp.write("    void ToPacket(INetPacket& packet)\n")
    fp.write("    {\n")

    for i in range(0,len(str)):
        element = str[i]
        key = element[0]
        value = element[1]
        parse_element_to_packet(fp, key, value)
    fp.write("    }\n")

    fp.write("    void FromPacket(INetPacket& packet)\n")
    fp.write("    {\n")
    fp.write("        int size;\n")

    for i in range(0, len(str)):
        element = str[i]
        key = element[0]
        value = element[1]
        parse_element_from_packet(fp,key,value)

    fp.write("    }\n")

    fp.write("}\n")

    fp.flush()
    fp.close()
Exemple #3
0
def reach_the_deepest_lists_and_modify(Prg, Group, Fun, Params):
    # if the obj has more highlighted words/hit, it's more important for the user.
    if util.is_list(Group) and Group:

        # if one member is list, all members are list
        GroupHasListsMembers = util.is_list(Group[0])

        if GroupHasListsMembers:
            for ListMember in Group:
                reach_the_deepest_lists_and_modify(Prg, ListMember, Fun,
                                                   Params)
        else:
            # modify the original values in Group
            Fun(Prg, Group, Params)
Exemple #4
0
def sentence_from_memory(Prg, Source, LineNum, Strip=False):
    Msg = ""
    if "DocumentObjectsLoaded" not in Prg:
        Msg = f"DocumentsObjectsLoaded not in Prg"

    elif Source not in Prg["DocumentObjectsLoaded"]:
        Msg = f"DocumentsObjectsLoaded: {Source} is not loaded"

    elif "Sentences" not in Prg["DocumentObjectsLoaded"][Source]:
        Msg = f"DocumentsObjectsLoaded: {Source} no Sentences"

    elif not util.is_list(Prg["DocumentObjectsLoaded"][Source]["Sentences"]):
        Sentences = Prg["DocumentObjectsLoaded"][Source]["Sentences"]
        Msg = f"DocumentsObjectsLoaded: incorrect type: Sentences = {str(Sentences)}"

    elif len(Prg["DocumentObjectsLoaded"][Source]["Sentences"]) - 1 < LineNum:
        Msg = f"DocumentsObjectsLoaded: {Source} unknown linenum: {LineNum}"

    if Msg:
        print(Msg)
        util.log(Prg, Msg)
        return False, Msg

    Line = Prg["DocumentObjectsLoaded"][Source]["Sentences"][LineNum]
    if Strip:
        return True, Line.strip()
    return True, Line
Exemple #5
0
    def FMOBNDgroup(self):
        broken_bonds = self._fragmentation.getExplicitlyBreakAtomPairs()
        if not is_list(broken_bonds):
            raise TypeError
        if len(broken_bonds) == 0:
            return "\n"

        return " $FMOBND%s\n $END" % self._getBondGroupData(broken_bonds)
Exemple #6
0
	def FMOBNDgroup(self):
		broken_bonds = self._fragmentation.getExplicitlyBreakAtomPairs()
		if not is_list(broken_bonds):
			raise TypeError
		if len(broken_bonds) == 0:
			return "\n"

		return " $FMOBND%s\n $END" % self._getBondGroupData(broken_bonds)
Exemple #7
0
 def __new__(cls, i, *args, **kw):
     if isinstance(i, NotificationId):
         return i
     
     if is_list(i):
         i = reduce(int.__or__, map(int, i), 0)
     else:
         i = int(i)
         
     #TODO: check val
     return super(NotificationId, cls).__new__(cls, i, *args, **kw)
Exemple #8
0
def parse_element_to_packet_lua(fp, k, v):
    func_name = lua_type_map_to_func(v,False)
    #封包
    if is_inner_type(v) == True:
        fp.write("    packet:" + func_name + "(self." + k.lower() + ")\n")
    elif util.is_list(v) and len(v) == 1:#vector
        table_name = v[0].lower() + "_list"
        fp.write("    self." + table_name + " = self." + table_name + " or {}\n")
        fp.write("    local len = #self." + table_name + "\n")
        fp.write("    packet:writeInt(len)\n")
        fp.write("    for i = 1,len do\n")
        if is_inner_type(v[0]) == True:
            func_name = lua_type_map_to_func(v[0],False)
            fp.write("        packet:" + func_name + "(self." + table_name + ")\n")
            fp.write("        end\n")
        else:
            fp.write("        self." + table_name + "to_packet(packet)\n")
            fp.write("    end\n")
    elif util.is_list(v) and len(v) == 2:#map
        table_name = v[0].lower() + "_record"
        fp.write("    self." + table_name + " = self." + table_name + " or {}\n")
        #计算出record中的长度  不能简单的用#去取 要通过for k,v in pairs获得长度
        fp.write("    local len = 0\n")
        fp.write("    for k,v in pairs(self." + table_name + ") do\n")
        fp.write("        len = len + 1\n")
        fp.write("    end\n")

        fp.write("    packet:writeInt(len)\n")
        fp.write("    for k,v in pairs(self." + table_name + ") do\n")

        key_func = lua_type_map_to_func(v[0],False)
        fp.write("        packet:" + key_func + "(k)\n")

        if is_inner_type(v[1]) == True:
            func_name = lua_type_map_to_func(v[1],False)
            fp.write("        packet:" + func_name + "(v)\n")
        else:
            fp.write("        v:to_packet(packet)\n")

        fp.write("    end\n")
        pass
Exemple #9
0
def parse_element_packet_to_lua(fp, k, v):
    func_name = lua_type_map_to_func(v,True)
    #解包
    if is_inner_type(v) == True:
        fp.write("    self." + k.lower() + " = packet:" + func_name + "()\n")
    elif util.is_list(v) and len(v) == 1:#vector
        fp.write("    local len = packet:readInt()\n")
        table_name = v[0].lower() + "_list"
        fp.write("    local " + table_name + " = {}\n")
        if is_inner_type(v[0]) == True:
            func_name = lua_type_map_to_func(v[0],True)
            fp.write("    local tmp = packet:" + func_name + "()\n")
            fp.write("    self." + table_name + "[#self." + table_name + " + 1] = tmp\n")
            pass
        else:
            fp.write("    for i = 1,len do\n")
            fp.write("        local tmp = require(\"lua.component.protocol." + v[0] + "\").new()\n")
            fp.write("        tmp:packet_to(packet)\n")
            fp.write("        self." + table_name + "[#self." + table_name + " + 1] = tmp\n")
            fp.write("    end\n")
            pass
    elif util.is_list(v) and len(v) == 2:#map
        fp.write("    local len = packet:readInt()\n")
        table_name = k.lower() + "_record"
        fp.write("    local " + table_name + " = {}\n")
        ##v[0] 肯定是内置对象  v[1] 不见得
        key_func = lua_type_map_to_func(v[0],True)
        fp.write("    for i = 1, len do\n")
        fp.write("        local key = packet:" + key_func + "()\n")
        if is_inner_type(v[1]) == True:
            func_name = lua_type_map_to_func(v[1],True)
            fp.write("        local value = packet:" + func_name + "()\n")
        else:
            fp.write("        local value = require(\"lua.component.protocol." + v[1] + "\").new()\n")
            fp.write("        value:packet_to(packet)\n")

        fp.write("        self." + table_name + "[key] = value\n")

        fp.write("    end\n")
Exemple #10
0
 def TxtToObj(TokenTxtList, Index,
              FileSourceBaseName):  # recursive txt-> TokenObj converter
     TokenObjects = []
     for Elem in TokenTxtList:
         if util.is_str(Elem):
             TokenObjects.append(
                 tokens.TokenObj(Elem,
                                 Index,
                                 Prg=Prg,
                                 WordsDetected=WordsDetected,
                                 FileSourceBaseName=FileSourceBaseName))
         if util.is_list(Elem):
             TokenObjects.append(TxtToObj(Elem, Index, FileSourceBaseName))
     return TokenObjects
Exemple #11
0
def parse_element_from_packet(fp, k, v):
    if is_inner_type(v) == True:
        fp.write("        packet >> " + k + ";\n")
    elif util.is_list(v) and len(v) == 1: #vector
        fp.write("        packet >> size;\n")
        fp.write("        for(int i = 0; i < size; i++)\n")
        fp.write("        {\n")
        if is_inner_type(v[0]) == True:
            fp.write("            " + v[0] + " value;\n")
            fp.write("            packet >> value;\n")
            fp.write("            " + k + ".push_back(value);\n")
        else:
            fp.write("            " + v[0] + " info;\n")
            fp.write("            info.FromPacket(packet);\n")
            fp.write("            " + k + ".push_back(info);\n")
        fp.write("        }\n")
    elif util.is_list(v) and len(v) == 2: #map
        fp.write("        packet >> size;\n")
        fp.write("        for(int i = 0; i < size; i++)\n")
        fp.write("        {\n")
        fp.write("            " + v[0] + " key;\n")
        fp.write("            " + v[1] + " value;\n")
        if is_inner_type(v[0]) == True:
            fp.write("            packet >> key;\n")
        else:
            fp.write("            key.FromPacket(packet);\n")

        if is_inner_type(v[1]) == True:
            fp.write("            packet >> value;\n")
        else:
            fp.write("            value.FromPacket(packet);\n")

        fp.write("            " + k + ".insert(make_pair(key,value));\n")
        fp.write("        }\n")
    else:
        fp.write("        " + k + ".FromPacket(packet);\n")
Exemple #12
0
 def _restore(self, obj):
     if has_tag(obj, tags.ID):
         restore = self._restore_id
     elif has_tag(obj, tags.REF):  # Backwards compatibility
         restore = self._restore_ref
     elif has_tag(obj, tags.TYPE):
         restore = self._restore_type
     elif has_tag(obj, tags.REPR):  # Backwards compatibility
         restore = self._restore_repr
     elif has_tag(obj, tags.OBJECT):
         restore = self._restore_object
     elif util.is_list(obj):
         restore = self._restore_list
     elif has_tag(obj, tags.TUPLE):
         restore = self._restore_tuple
     elif has_tag(obj, tags.SET):
         restore = self._restore_set
     elif util.is_dictionary(obj):
         restore = self._restore_dict
     else:
         restore = lambda x: x
     return restore(obj)
Exemple #13
0
 def _restore(self, obj):
     if has_tag(obj, tags.ID):
         restore = self._restore_id
     elif has_tag(obj, tags.REF): # Backwards compatibility
         restore = self._restore_ref
     elif has_tag(obj, tags.TYPE):
         restore = self._restore_type
     elif has_tag(obj, tags.REPR): # Backwards compatibility
         restore = self._restore_repr
     elif has_tag(obj, tags.OBJECT):
         restore = self._restore_object
     elif util.is_list(obj):
         restore = self._restore_list
     elif has_tag(obj, tags.TUPLE):
         restore = self._restore_tuple
     elif has_tag(obj, tags.SET):
         restore = self._restore_set
     elif util.is_dictionary(obj):
         restore = self._restore_dict
     else:
         restore = lambda x: x
     return restore(obj)
Exemple #14
0
    def _get_flattener(self, obj):

        if util.is_primitive(obj):
            return lambda obj: obj

        list_recurse = self._list_recurse

        if util.is_list(obj):
            if self._mkref(obj):
                return list_recurse
            else:
                self._push()
                return self._getref

        # We handle tuples and sets by encoding them in a "(tuple|set)dict"
        if util.is_tuple(obj):
            if not self.unpicklable:
                return list_recurse
            return lambda obj: {tags.TUPLE: [self._flatten(v) for v in obj]}

        if util.is_set(obj):
            if not self.unpicklable:
                return list_recurse
            return lambda obj: {tags.SET: [self._flatten(v) for v in obj]}

        if util.is_dictionary(obj):
            return self._flatten_dict_obj

        if util.is_type(obj):
            return _mktyperef

        if util.is_object(obj):
            return self._ref_obj_instance

        # else, what else? (methods, functions, old style classes...)
        return None
Exemple #15
0
 def test_positive_types( self ):
     self.assertTrue( util.is_string( "abcd" ) )
     self.assertTrue( util.is_boolean( True ) )
     self.assertTrue( util.is_integer( 1234 ) )
     self.assertTrue( util.is_list( [1,2,3,4]) )
     self.assertTrue( util.is_dict( {"foo":"bar"} ) )
Exemple #16
0
 def test_neg_lists( self ):
     self.assertFalse( util.is_list( "1234" ) )
     self.assertFalse( util.is_list( 12345 ) )
Exemple #17
0
def operator_exec(Tokens, Scope="subsentence", SubSentenceMulti=100, WordPositionMulti=100, CallLevel=0, ProgressBarConsole=None, ProgressBarChange=3):

    for Position in range(0, len(Tokens)): # expand all groups in all levels first
        Token = Tokens[Position]
        if util.is_list(Token):
            operator_exec(Token, Scope=Scope, SubSentenceMulti=SubSentenceMulti, WordPositionMulti=WordPositionMulti, CallLevel=CallLevel+1, ProgressBarConsole=ProgressBarConsole)
            Tokens[Position] = Token[0]
            Tokens[Position].IsGroup = True # the main, collector, result object is group

    for Operator in Operators:

        # during operator exec, the positions can be changed so I have to check them in every Op
        OperatorPositions = get_operator_positions(Tokens)

        # if operator exist in the position lists and it has any open position
        while (Operator in OperatorPositions) and OperatorPositions[Operator]:

            # The first progress bar change = 2 because at caller position I updated the bar with 1.
            # but later the change has to be 3, it's the default value
            if ProgressBarConsole:                                   # I work with 3 tokens in same time:
                ProgressBarConsole.update(Change= ProgressBarChange) # the operators and two operands
                                                                     # but 1 ProgressBar update happened before operator_exec

            OperatorPositionLast = OperatorPositions[Operator].pop()
            ParamLeft  = Tokens[OperatorPositionLast - 1]
            ParamRight = Tokens[OperatorPositionLast + 1]

            ###############################################################
            if Operator == "OR": # slow test: ..eading
                ResultOpExec = ParamLeft.Results + ParamRight.Results

            ###############################################################
            elif Operator == "AND": # slow test: prefer AND reading AND cards AND the AND yet
                if len(ParamLeft.Results) >= len(ParamRight.Results):
                    ResultsBig =  ParamLeft.Results
                    ResultsSmall = ParamRight.Results
                else:
                    ResultsBig = ParamRight.Results
                    ResultsSmall = ParamLeft.Results

                ResBigScoped = set()
                for ResBig in ResultsBig:
                    ResBigScoped.add(ResBig.Scopes[Scope])

                ResultOpExec = []
                for ResSmall in ResultsSmall:
                    if ResSmall.Scopes[Scope] in ResBigScoped:
                        ResultOpExec.append(ResSmall)

            ###############################################################
            elif Operator == "THEN":

                ResRightScoped = dict()
                for ResRight in ParamRight.Results:
                    # store the current scope AND the finest scope to detect the word order later
                    ResRightScope = ResRight.Scopes[Scope]
                    if ResRightScope not in ResRightScoped:
                        ResRightScoped[ResRightScope] = []

                    ResRightScoped[ResRightScope].append(ResRight.Scopes["word"])

                ResultOpExec = []
                if ResRightScoped: # try to find common elems if something is in Right
                    for ResLeft in ParamLeft.Results:
                        if not ResRightScoped:
                            break

                        ResLeftScope = ResLeft.Scopes[Scope]
                        if ResLeftScope in ResRightScoped:

                            for ResRightScopedWord in ResRightScoped[ResLeftScope]:
                                if ResLeft.Scopes["word"] < ResRightScopedWord:
                                    ResultOpExec.append(ResLeft)
                                    # remove the right scope because one hit is enough
                                    # from one sentence
                                    # and I decrease the work for next for loops
                                    del ResRightScoped[ResLeftScope]
                                    break
            ###############################################################

            OperatorObj = Tokens[OperatorPositionLast]
            ObjResult = TokenObj(ParamLeft.words() + OperatorObj.words() + ParamRight.words(), Results=ResultOpExec, FileSourceBaseName=ParamLeft.FileSourceBaseName)
            ObjResult.Explain = [ParamLeft, OperatorObj, ParamRight]
            Tokens[OperatorPositionLast-1] = ObjResult
            Tokens.pop(OperatorPositionLast + 1)
            Tokens.pop(OperatorPositionLast)
Exemple #18
0
 def test_is_list(self):
     self.assertTrue( util.is_list(self.lsimple))