#!/usr/bin/env python

#

# Copyright 2007 Google Inc.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

from google.net.proto import ProtocolBuffer

import array

import dummy_thread as thread

__pychecker__ = """maxreturns=0 maxbranches=0 no-callinit

                   unusednames=printElemNumber,debug_strs no-special"""

class PropertyValue_ReferenceValuePathElement(ProtocolBuffer.ProtocolMessage):

  has_type_ = 0

  type_ = ""

  has_id_ = 0

  id_ = 0

  has_name_ = 0

  name_ = ""

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def type(self): return self.type_

  def set_type(self, x):

    self.has_type_ = 1

    self.type_ = x

  def clear_type(self):

    if self.has_type_:

      self.has_type_ = 0

      self.type_ = ""

  def has_type(self): return self.has_type_

  def id(self): return self.id_

  def set_id(self, x):

    self.has_id_ = 1

    self.id_ = x

  def clear_id(self):

    if self.has_id_:

      self.has_id_ = 0

      self.id_ = 0

  def has_id(self): return self.has_id_

  def name(self): return self.name_

  def set_name(self, x):

    self.has_name_ = 1

    self.name_ = x

  def clear_name(self):

    if self.has_name_:

      self.has_name_ = 0

      self.name_ = ""

  def has_name(self): return self.has_name_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_type()): self.set_type(x.type())

    if (x.has_id()): self.set_id(x.id())

    if (x.has_name()): self.set_name(x.name())

  def Equals(self, x):

    if x is self: return 1

    if self.has_type_ != x.has_type_: return 0

    if self.has_type_ and self.type_ != x.type_: return 0

    if self.has_id_ != x.has_id_: return 0

    if self.has_id_ and self.id_ != x.id_: return 0

    if self.has_name_ != x.has_name_: return 0

    if self.has_name_ and self.name_ != x.name_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_type_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: type not set.')

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthString(len(self.type_))

    if (self.has_id_): n += 2 + self.lengthVarInt64(self.id_)

    if (self.has_name_): n += 2 + self.lengthString(len(self.name_))

    return n + 1

  def Clear(self):

    self.clear_type()

    self.clear_id()

    self.clear_name()

  def OutputUnchecked(self, out):

    out.putVarInt32(122)

    out.putPrefixedString(self.type_)

    if (self.has_id_):

      out.putVarInt32(128)

      out.putVarInt64(self.id_)

    if (self.has_name_):

      out.putVarInt32(138)

      out.putPrefixedString(self.name_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 116: break

      if tt == 122:

        self.set_type(d.getPrefixedString())

        continue

      if tt == 128:

        self.set_id(d.getVarInt64())

        continue

      if tt == 138:

        self.set_name(d.getPrefixedString())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))

    if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))

    if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))

    return res

class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):

  has_x_ = 0

  x_ = 0.0

  has_y_ = 0

  y_ = 0.0

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def x(self): return self.x_

  def set_x(self, x):

    self.has_x_ = 1

    self.x_ = x

  def clear_x(self):

    if self.has_x_:

      self.has_x_ = 0

      self.x_ = 0.0

  def has_x(self): return self.has_x_

  def y(self): return self.y_

  def set_y(self, x):

    self.has_y_ = 1

    self.y_ = x

  def clear_y(self):

    if self.has_y_:

      self.has_y_ = 0

      self.y_ = 0.0

  def has_y(self): return self.has_y_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_x()): self.set_x(x.x())

    if (x.has_y()): self.set_y(x.y())

  def Equals(self, x):

    if x is self: return 1

    if self.has_x_ != x.has_x_: return 0

    if self.has_x_ and self.x_ != x.x_: return 0

    if self.has_y_ != x.has_y_: return 0

    if self.has_y_ and self.y_ != x.y_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_x_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: x not set.')

    if (not self.has_y_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: y not set.')

    return initialized

  def ByteSize(self):

    n = 0

    return n + 18

  def Clear(self):

    self.clear_x()

    self.clear_y()

  def OutputUnchecked(self, out):

    out.putVarInt32(49)

    out.putDouble(self.x_)

    out.putVarInt32(57)

    out.putDouble(self.y_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 44: break

      if tt == 49:

        self.set_x(d.getDouble())

        continue

      if tt == 57:

        self.set_y(d.getDouble())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_x_: res+=prefix+("x: %s\n" % self.DebugFormat(self.x_))

    if self.has_y_: res+=prefix+("y: %s\n" % self.DebugFormat(self.y_))

    return res

class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):

  has_email_ = 0

  email_ = ""

  has_auth_domain_ = 0

  auth_domain_ = ""

  has_nickname_ = 0

  nickname_ = ""

  has_gaiaid_ = 0

  gaiaid_ = 0

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def email(self): return self.email_

  def set_email(self, x):

    self.has_email_ = 1

    self.email_ = x

  def clear_email(self):

    if self.has_email_:

      self.has_email_ = 0

      self.email_ = ""

  def has_email(self): return self.has_email_

  def auth_domain(self): return self.auth_domain_

  def set_auth_domain(self, x):

    self.has_auth_domain_ = 1

    self.auth_domain_ = x

  def clear_auth_domain(self):

    if self.has_auth_domain_:

      self.has_auth_domain_ = 0

      self.auth_domain_ = ""

  def has_auth_domain(self): return self.has_auth_domain_

  def nickname(self): return self.nickname_

  def set_nickname(self, x):

    self.has_nickname_ = 1

    self.nickname_ = x

  def clear_nickname(self):

    if self.has_nickname_:

      self.has_nickname_ = 0

      self.nickname_ = ""

  def has_nickname(self): return self.has_nickname_

  def gaiaid(self): return self.gaiaid_

  def set_gaiaid(self, x):

    self.has_gaiaid_ = 1

    self.gaiaid_ = x

  def clear_gaiaid(self):

    if self.has_gaiaid_:

      self.has_gaiaid_ = 0

      self.gaiaid_ = 0

  def has_gaiaid(self): return self.has_gaiaid_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_email()): self.set_email(x.email())

    if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())

    if (x.has_nickname()): self.set_nickname(x.nickname())

    if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())

  def Equals(self, x):

    if x is self: return 1

    if self.has_email_ != x.has_email_: return 0

    if self.has_email_ and self.email_ != x.email_: return 0

    if self.has_auth_domain_ != x.has_auth_domain_: return 0

    if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0

    if self.has_nickname_ != x.has_nickname_: return 0

    if self.has_nickname_ and self.nickname_ != x.nickname_: return 0

    if self.has_gaiaid_ != x.has_gaiaid_: return 0

    if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_email_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: email not set.')

    if (not self.has_auth_domain_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: auth_domain not set.')

    if (not self.has_gaiaid_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: gaiaid not set.')

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthString(len(self.email_))

    n += self.lengthString(len(self.auth_domain_))

    if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))

    n += self.lengthVarInt64(self.gaiaid_)

    return n + 4

  def Clear(self):

    self.clear_email()

    self.clear_auth_domain()

    self.clear_nickname()

    self.clear_gaiaid()

  def OutputUnchecked(self, out):

    out.putVarInt32(74)

    out.putPrefixedString(self.email_)

    out.putVarInt32(82)

    out.putPrefixedString(self.auth_domain_)

    if (self.has_nickname_):

      out.putVarInt32(90)

      out.putPrefixedString(self.nickname_)

    out.putVarInt32(144)

    out.putVarInt64(self.gaiaid_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 68: break

      if tt == 74:

        self.set_email(d.getPrefixedString())

        continue

      if tt == 82:

        self.set_auth_domain(d.getPrefixedString())

        continue

      if tt == 90:

        self.set_nickname(d.getPrefixedString())

        continue

      if tt == 144:

        self.set_gaiaid(d.getVarInt64())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))

    if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))

    if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))

    if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))

    return res

class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):

  has_app_ = 0

  app_ = ""

  def __init__(self, contents=None):

    self.pathelement_ = []

    if contents is not None: self.MergeFromString(contents)

  def app(self): return self.app_

  def set_app(self, x):

    self.has_app_ = 1

    self.app_ = x

  def clear_app(self):

    if self.has_app_:

      self.has_app_ = 0

      self.app_ = ""

  def has_app(self): return self.has_app_

  def pathelement_size(self): return len(self.pathelement_)

  def pathelement_list(self): return self.pathelement_

  def pathelement(self, i):

    return self.pathelement_[i]

  def mutable_pathelement(self, i):

    return self.pathelement_[i]

  def add_pathelement(self):

    x = PropertyValue_ReferenceValuePathElement()

    self.pathelement_.append(x)

    return x

  def clear_pathelement(self):

    self.pathelement_ = []

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_app()): self.set_app(x.app())

    for i in xrange(x.pathelement_size()): self.add_pathelement().CopyFrom(x.pathelement(i))

  def Equals(self, x):

    if x is self: return 1

    if self.has_app_ != x.has_app_: return 0

    if self.has_app_ and self.app_ != x.app_: return 0

    if len(self.pathelement_) != len(x.pathelement_): return 0

    for e1, e2 in zip(self.pathelement_, x.pathelement_):

      if e1 != e2: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_app_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: app not set.')

    for p in self.pathelement_:

      if not p.IsInitialized(debug_strs): initialized=0

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthString(len(self.app_))

    n += 2 * len(self.pathelement_)

    for i in xrange(len(self.pathelement_)): n += self.pathelement_[i].ByteSize()

    return n + 1

  def Clear(self):

    self.clear_app()

    self.clear_pathelement()

  def OutputUnchecked(self, out):

    out.putVarInt32(106)

    out.putPrefixedString(self.app_)

    for i in xrange(len(self.pathelement_)):

      out.putVarInt32(115)

      self.pathelement_[i].OutputUnchecked(out)

      out.putVarInt32(116)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 100: break

      if tt == 106:

        self.set_app(d.getPrefixedString())

        continue

      if tt == 115:

        self.add_pathelement().TryMerge(d)

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))

    cnt=0

    for e in self.pathelement_:

      elm=""

      if printElemNumber: elm="(%d)" % cnt

      res+=prefix+("PathElement%s {\n" % elm)

      res+=e.__str__(prefix + "  ", printElemNumber)

      res+=prefix+"}\n"

      cnt+=1

    return res

class PropertyValue(ProtocolBuffer.ProtocolMessage):

  has_int64value_ = 0

  int64value_ = 0

  has_booleanvalue_ = 0

  booleanvalue_ = 0

  has_stringvalue_ = 0

  stringvalue_ = ""

  has_doublevalue_ = 0

  doublevalue_ = 0.0

  has_pointvalue_ = 0

  pointvalue_ = None

  has_uservalue_ = 0

  uservalue_ = None

  has_referencevalue_ = 0

  referencevalue_ = None

  def __init__(self, contents=None):

    self.lazy_init_lock_ = thread.allocate_lock()

    if contents is not None: self.MergeFromString(contents)