Properties.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-
  
 
 
 
 
import sys
import string
 
import OpenRTM_aist
 
 
 
class Properties:
  """
  """
 
  
  def __init__(self, key=None, value=None, defaults_map=None, defaults_str=None, num=None, prop=None):
    self.default_value = ""
    self.root = None
    self.empty = ""
    self.leaf = []
 
    # Properties::Properties(const Properties& prop)
    if prop:
      self.name          = prop.name
      self.value         = prop.value
      self.default_value = prop.default_value
 
      keys = prop.propertyNames()
      for _key in keys:
        node = None
        node = prop.getNode(_key)
        if node:
          self.setDefault(_key, node.default_value)
          self.setProperty(_key, node.value)
          
      return
 
    # Properties::Properties(const char* key, const char* value)
    if key:
      self.name = key
      if value is None:
        self.value = ""
      else:
        self.value = value
      return
 
    self.name  = ""
    self.value = ""
 
    # Properties::Properties(std::map<std::string, std::string>& defaults)
    if defaults_map:
      #for i in range(len(defaults_map.items())):
      #  self.setDefault(defaults_map.keys()[i], defaults_map.values()[i])
      for key, value in list(defaults_map.items()):
        self.setDefault(key, value)
      return
 
    if defaults_str:
      if num is None:
        _num = sys.maxsize
      else:
        _num = num
      self.setDefaults(defaults_str, _num)
      return
 
 
  
  def assigmentOperator(self, prop):
    self.clear()
    self.name = prop.name
    self.value = prop.value
    self.default_value = prop.default_value
 
    keys = prop.propertyNames()
 
    for key in keys:
      node = None
      node = prop.getNode(key)
      if node:
        self.setDefault(key, node.default_value)
        self.setProperty(key, node.value)
 
    return self
 
 
  
  def __del__(self):
    self.clear()
    if self.root:
      self.root.removeNode(self.name)
    return
 
  #============================================================
  # public functions
  #============================================================
 
 
  
  def getName(self):
    return self.name
 
 
  
  def getValue(self):
    return self.value
 
 
  
  def getDefaultValue(self):
    return self.default_value
 
 
  
  def getLeaf(self):
    return self.leaf
 
 
  
  def getRoot(self):
    return self.root
 
 
  
  def getProperty(self, key, default=None):
    if default is None:
      keys = []
      #keys = string.split(key, ".")
      self.split(key, ".", keys)
 
      node = None
      node = self._getNode(keys, 0, self)
      if node:
        if node.value:
          return node.value
        else:
          return node.default_value
      return self.empty
 
    else:
      value = self.getProperty(key)
      if value:
        return value
      else:
        return default
 
 
  
  def getDefault(self, key):
    keys = []
    #keys = string.split(key, ".")
    self.split(key, ".", keys)
    node = None
    node = self._getNode(keys, 0, self)
    if node:
      return node.default_value
 
    return self.empty
 
 
  
  def setProperty(self, key, value=None):
    if value is not None:
      keys = []
      #keys = string.split(key, ".")
      self.split(key, ".", keys)
      curr = self
      for _key in keys:
        next = curr.hasKey(_key)
        if next is None:
          next = OpenRTM_aist.Properties(key=_key)
          next.root = curr
          curr.leaf.append(next)
        curr = next
      retval = curr.value
      curr.value = value
      return retval
 
    else:
      self.setProperty(key, self.getProperty(key))
      prop = self.getNode(key)
      return prop.value
 
 
  
  def setDefault(self, key, value):
    keys = []
    self.split(key, ".", keys)
    #keys = string.split(key, ".")
 
    curr = self
    for _key in keys:
      next = curr.hasKey(_key)
      if next is None:
        next = OpenRTM_aist.Properties(key=_key)
        next.root = curr
        curr.leaf.append(next)
      curr = next
    if value != "" and value[-1] == "\n":
      value = value[0:len(value)-1]
    curr.default_value = value
    return value
 
 
  
  def setDefaults(self, defaults, num = None):
    if num is None:
      num = sys.maxsize
 
    i = 0
    len_ = len(defaults)
    while 1:
      if i > num or i > (len_ - 1) or defaults[i] == "":
        break
 
      key = [defaults[i]]
      value = [defaults[i+1]]
 
      OpenRTM_aist.eraseHeadBlank(key)
      OpenRTM_aist.eraseTailBlank(key)
 
      OpenRTM_aist.eraseHeadBlank(value)
      OpenRTM_aist.eraseTailBlank(value)
 
      self.setDefault(key[0], value[0])
 
      i +=2
 
 
 
  #============================================================
  # load and save functions
  #============================================================
 
  
  def list(self, out):
    self._store(out, "", self)
    return
 
 
  
  def load(self, inStream):
    pline = ""
    for readStr in inStream:
      if not readStr:
        continue
      
      tmp = [readStr]
      OpenRTM_aist.eraseHeadBlank(tmp)
      _str = tmp[0]
      
      if _str[0] == "#" or _str[0] == "!" or _str[0] == "\n":
        continue
 
      _str = _str.rstrip('\r\n')
 
      if _str[len(_str)-1] == "\\" and not OpenRTM_aist.isEscaped(_str, len(_str)-1):
        #_str = _str[0:len(_str)-1]
        tmp = [_str[0:len(_str)-1]]
        OpenRTM_aist.eraseTailBlank(tmp)
        #pline += _str
        pline += tmp[0]
        continue
      pline += _str
      if pline == "":
        continue
 
      key = []
      value = []
      self.splitKeyValue(pline, key, value)
      key[0] = OpenRTM_aist.unescape(key)
      OpenRTM_aist.eraseHeadBlank(key)
      OpenRTM_aist.eraseTailBlank(key)
 
      value[0] = OpenRTM_aist.unescape(value)
      OpenRTM_aist.eraseHeadBlank(value)
      OpenRTM_aist.eraseTailBlank(value)
 
      self.setProperty(key[0], value[0])
      pline = ""
 
 
  
  def save(self, out, header):
    self.store(out, header)
    return
 
 
  
  def store(self, out, header):
    out.write("#"+header+"\n")
    self._store(out, "", self)
 
 
  #============================================================
  # other util functions
  #============================================================
 
  
  def propertyNames(self):
    names = []
    for leaf in self.leaf:
      self._propertyNames(names, leaf.name, leaf)
    return names
 
 
  
  def size(self):
    return len(self.propertyNames())
 
 
  
  def findNode(self, key):
    if not key:
      return None
 
    keys = []
    self.split(key, '.', keys)
    return self._getNode(keys, 0, self)
 
 
  
  def getNode(self, key):
    if not key:
      return self
 
    leaf = self.findNode(key)
    if leaf:
      return leaf
 
    self.createNode(key)
    return self.findNode(key)
 
 
  
  def createNode(self, key):
    if not key:
      return False
 
    if self.findNode(key):
      return False
    
    self.setProperty(key,"")
    return True
 
 
  
  def removeNode(self, leaf_name):
    len_ = len(self.leaf)
    for i in range(len_):
      idx = (len_ - 1) - i
      if self.leaf[idx].name == leaf_name:
        prop = self.leaf[idx]
        del self.leaf[idx]
        return prop
    return None
 
 
  
  def hasKey(self, key):
    for leaf in self.leaf:
      if leaf.name == key:
        return leaf
 
    return None
 
 
  
  def clear(self):
    len_ = len(self.leaf)
    for i in range(len_):
      if self.leaf[-1]:
        del self.leaf[-1]
 
    return
 
 
  
  def mergeProperties(self, prop):
    keys = prop.propertyNames()
 
    for i in range(prop.size()):
      self.setProperty(keys[i], prop.getProperty(keys[i]))
 
    return self
 
 
  
  def splitKeyValue(self, _str, key, value):
    i = 0
    length = len(_str)
 
    while i < length:
      if (_str[i] == ":" or _str[i] == "=") and not OpenRTM_aist.isEscaped(_str, i):
        key.append(_str[0:i])
        value.append(_str[i+1:])
        return
      i += 1
 
    # If no ':' or '=' exist, ' ' would be delimiter.
    i = 0
    while i < length:
      if (_str[i] == " ") and not OpenRTM_aist.isEscaped(_str, i):
        key.append(_str[0:i])
        value.append(_str[i+1:])
        return
      i += 1
 
    key.append(_str)
    value.append("")
    return
 
 
  
  def split(self, _str, delim, value):
    if _str == "":
      return False
 
    begin_it = end_it = 0
 
    length = len(_str)
 
    while end_it < length:
      if _str[end_it] == delim and not OpenRTM_aist.isEscaped(_str, end_it):
        value.append(_str[begin_it:end_it])
        begin_it = end_it + 1
      end_it += 1
 
    value.append(_str[begin_it:end_it])
    return True
 
 
  
  def _getNode(self, keys, index, curr):
    next = curr.hasKey(keys[index])
    if next is None:
      return None
 
    if index < (len(keys) - 1):
      index+=1
      return next._getNode(keys, index, next)
    else:
      return next
 
    return None
 
 
  
  def _propertyNames(self, names, curr_name, curr):
    if len(curr.leaf) > 0:
      for i in range(len(curr.leaf)):
        next_name = curr_name+"."+curr.leaf[i].name
        self._propertyNames(names, next_name, curr.leaf[i])
    else:
      names.append(curr_name)
 
    return
 
 
  
  def _store(self, out, curr_name, curr):
    if len(curr.leaf) > 0:
      for i in range(len(curr.leaf)):
        if curr_name == "":
          next_name = curr.leaf[i].name
        else:
          next_name = curr_name+"."+curr.leaf[i].name
        self._store(out, next_name, curr.leaf[i])
        
    else:
      val = curr.value
      if val == "":
        val = curr.default_value
      out.write(curr_name+": "+val+"\n")
 
    return
 
 
  
  def indent(self, index):
    space = ""
 
    for i in range(index-1):
      space += "  "
 
    return space
 
 
  
  def _dump(self, out, curr, index):
    if index != 0:
      #ut.write(self.indent(index)+"- "+curr.name)
      out[0]+=self.indent(index)+"- "+curr.name
 
    if curr.leaf == []:
      if curr.value == "":
        #out.write(": "+curr.default_value+"\n")
        out[0]+=": "+curr.default_value+"\n"
      else:
        #out.write(": "+curr.value+"\n")
        out[0]+=": "+str(curr.value)+"\n"
      return out[0]
 
    if index != 0:
      #out.write("\n")
      out[0]+="\n"
 
    for i in range(len(curr.leaf)):
      self._dump(out, curr.leaf[i], index + 1)
 
    return out[0]
 
 
  
  def __str__(self): 
    string=[""]
    return self._dump(string, self, 0)