clientbot/tools/CArg.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# module CArg
#
#    Copyright (C) 2019  AleaJactaEst
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

from ctypes import *
from tools import Enum

# #####################################################
# persistent_data.h:140  #  struct CArg
# #####################################################
class CArgV1(Structure):
    _fields_ = [("i32_1", c_uint),
                ("i32_2", c_uint)]


class CArgV2(Structure):
    _fields_ = [("ex32_1", c_uint),
                ("ex32_2", c_uint)]


class CArgV3(Union):
    _fields_ = [("ex32", CArgV2),
                ("ExData32", c_uint),
                ("ExData64", c_ulong)]


class CArgV4(Structure):
    _fields_ = [("ExType", c_uint),
                ("ex", CArgV3)]


class CArgV5(Union):
    _fields_ = [("i", CArgV1),
                ("ii32", c_int),
                ("ii64", c_long),
                ("i32", c_uint),
                ("i64", c_ulong),
                ("f32", c_float),
                ("f64", c_double),
                ("ex", CArgV4)]

class CArg:
    #       union
    #       {
    #           struct
    #           {
    #               uint32  i32_1;
    #               uint32  i32_2;
    #           } i;
    #
    #           sint32  i32;
    #           sint64  i64;
    #           float   f32;
    #           double  f64;
    #
    #           struct
    #           {
    #               uint32  ExType;
    #               union
    #               {
    #                   struct
    #                   {
    #                       uint32  ex32_1;
    #                       uint32  ex32_2;
    #                   };
    #
    #                   uint32  ExData32;
    #                   uint64  ExData64;
    #               } ex;
    #           } ex;
    #       } _Value;

    def __init__(self):
        self._value = CArgV5()
        self._value.ii64 = 0
        self._value.i64 = 0
        self._type = 0
        self._string = 0
        self._type64 = False

    def read_Type(self):
        return self._type

    def write_Type(self, value):
        self._type = value

    def write_Type64(self, value):
        self._type64 = value

    def read_String(self):
        return self._string

    def write_String(self, value):
        self._string = value

    def read_i32_1(self):
        return self._value.i.i32_1

    def write_i32_1(self, value):
        self._value.i.i32_1 = value

    def read_i32_2(self):
        return self._value.i.i32_2

    def write_i32_2(self, value):
        self._value.i.i32_2 = value

    def read_i32(self):
        return self._value.i32

    def write_i32(self, value):
        self._value.i32 = value

    def read_i64(self):
        return self._value.i64

    def write_i64(self, value):
        self._value.i64 = value

    def read_f32(self):
        return self._value.f32

    def write_f32(self, value):
        self._value.f32 = value

    def read_f64(self):
        return self._value.f64

    def write_f64(self, value):
        self._value.f64 = value

    def read_ExType(self):
        return self._value.ex.ExType

    def write_ExType(self, value):
        self._value.ex.ExType = value

    def read_ex32_1(self):
        return self._value.ex.ex.ex32.ex32_1

    def write_ex32_1(self, value):
        self._value.ex.ex.ex32.ex32_1 = value

    def read_ex32_2(self):
        return self._value.ex.ex.ex32.ex32_2

    def write_ex32_2(self, value):
        self._value.ex.ex.ex32.ex32_2 = value

    def read_ExData32(self):
        return self._value.ex.ex.ExData32

    def write_ExData32(self, value):
        self._value.ex.ex.ExData32 = value

    def read_ExData64(self):
        return self._value.ex.ex.ExData64

    def write_ExData64(self, value):
        self._value.ex.ex.ExData64 = value

    def isExtended(self):
        if self._type == Enum.TType.EXTEND_TYPE:
            return True
        elif self._type == Enum.TType.STRUCT_BEGIN:
            self.log.error("Can't extract a value from a structure delimiter")
            sys.exit(2)
        elif self._type == Enum.TType.STRUCT_END:
            self.log.error("Can't extract a value from a structure delimiter")
            sys.exit(2)
        return False

    def isFlag(self):
        if self._type == Enum.TType.FLAG:
            return True
        else:
            return False

    def asUint(self):
        if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
            self.log.error("Can't extract a value from a structure delimiter")
            sys.exit(2)
        elif self._type == Enum.TType.SINT32:
            return self.read_i32()
        elif self._type == Enum.TType.UINT32:
            return self.read_i32()
        elif self._type == Enum.TType.SINT64:
            return self.read_i64()
        elif self._type == Enum.TType.UINT64:
            return self.read_i64()
        elif self._type == Enum.TType.FLOAT32:
            return self.read_i32()
        elif self._type == Enum.TType.FLOAT64:
            return self.read_i64()
        elif self._type == Enum.TType.STRING:
            return int(self._string)
        elif self._type == Enum.TType.FLAG:
            return "1"
        elif self._type == Enum.TType.EXTEND_TYPE:
            if self.read_ExType() == TExtendType.ET_SHEET_ID:
                return self.read_ExData32()
            elif self.read_ExType() == TExtendType.ET_ENTITY_ID:
                return self.read_ExData64()
        log = logging.getLogger('myLogger')
        log.error("This should never happen!")
        sys.exit(2)

    def __str__(self):
        log = logging.getLogger('myLogger')
        log.debug(self._type)
        if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
            return ''
        elif self._type64:
            # To be confirm for extend
            return str(self.read_ExData64())
        elif self._type == Enum.TType.SINT32:
            return str(self.read_i32())
        elif self._type == Enum.TType.UINT32:
            return str(self.read_i32())
        elif self._type == Enum.TType.SINT64:
            return str(self.read_i64())
        elif self._type == Enum.TType.UINT64:
            return str(self.read_i64())
        elif self._type == Enum.TType.FLOAT32:
            return str(self.read_i32())
        elif self._type == Enum.TType.FLOAT64:
            return str(self.read_i64())
        elif self._type == Enum.TType.STRING:
            return self._string
        elif self._type == Enum.TType.FLAG:
            return "1"
        return '?'

    def asSint(self):
        self.log.error("TODO")
        sys.exit(2)

    def asFloat(self):
        self.log.error("TODO")
        sys.exit(2)

    def asDouble(self):
        self.log.error("TODO")
        sys.exit(2)

    def asString(self):
        if self._type == Enum.TType.STRUCT_BEGIN or self._type == Enum.TType.STRUCT_END:
            self.log.error("Can't extract a value from a structure delimiter")
            sys.exit(2)
        elif self._type == Enum.TType.SINT32:
            return str(self.read_ii32())
        elif self._type == Enum.TType.UINT32:
            return str(self.read_i32())
        elif self._type == Enum.TType.SINT64:
            return str(self.read_ii64())
        elif self._type == Enum.TType.UINT64:
            return str(self.read_i64())
        elif self._type == Enum.TType.FLOAT32:
            return str(self.read_f32())
        elif self._type == Enum.TType.FLOAT64:
            return str(self.read_f64())
        elif self._type == Enum.TType.STRING:
            return self._string
        elif self._type == Enum.TType.FLAG:
            return "1"
        elif self._type == Enum.TType.EXTEND_TYPE:
            self.log.error("TODO")
            sys.exit(2)
            #       switch(_Value.ExType)
            #       {
            #       case ET_SHEET_ID:
            #           {
            #               NLMISC::CSheetId sheetId(_Value.ExData32);
            #               return sheetId.toString(true);
            #           }
            #       case ET_ENTITY_ID:
            #           {
            #               NLMISC::CEntityId entityId(_Value.ExData64);
            #               return entityId.toString();
            #           }
            #       default:
            #           break;
            #       }
        self.log.error("This should never happen!")
        sys.exit(2)

    def asUCString(self):
        self.log.error("TODO")
        sys.exit(2)

    def asEntityId(self):
        self.log.error("TODO")
        sys.exit(2)

    def asSheetId(self):
        self.log.error("TODO")
        sys.exit(2)

    def typeName(self):
        self.log.error("TODO")
        sys.exit(2)

# #####################################################