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 defaults_map.items():
        self.setDefault(key, value)
      return

    if defaults_str:
      if num is None:
        _num = sys.maxint
      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.maxint

    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)