text: # Copyright (c) 2017, The MITRE Corporation. All rights reserved.
  # See LICENSE.txt for complete terms.
  
  import sys
  
  from mixbox.binding_utils import *
  from . import cybox_common
  
  
  class Layer4ProtocolType(cybox_common.BaseObjectPropertyType):
      """Layer4ProtocolType specifies Layer 4 (OSI model) protocols, via a
      union of the Layer4ProtocolEnum type and the atomic xs:string
      type. Its base type is the CybOX Core cybox_common.BaseObjectPropertyType,
      for permitting complex (i.e. regular-expression based)
      specifications.This attribute is optional and specifies the
      expected type for the value of the specified property."""
  
      subclass = None
      superclass = cybox_common.BaseObjectPropertyType
      def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None):
          # PROP: This is a BaseObjectPropertyType subclass
          super(Layer4ProtocolType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_)
          self.datatype = _cast(None, datatype)
          self.valueOf_ = valueOf_
      def factory(*args_, **kwargs_):
          if Layer4ProtocolType.subclass:
              return Layer4ProtocolType.subclass(*args_, **kwargs_)
          else:
              return Layer4ProtocolType(*args_, **kwargs_)
      factory = staticmethod(factory)
      def get_datatype(self): return self.datatype
      def set_datatype(self, datatype): self.datatype = datatype
      def get_valueOf_(self): return self.valueOf_
      def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
      def hasContent_(self):
          if (
              self.valueOf_ or
              super(Layer4ProtocolType, self).hasContent_()
              ):
              return True
          else:
              return False
      def export(self, lwrite, level, namespace_='PortObj:', name_='Layer4ProtocolType', namespacedef_='', pretty_print=True):
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          showIndent(lwrite, level, pretty_print)
          lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
          already_processed = set()
          self.exportAttributes(lwrite, level, already_processed, namespace_, name_='Layer4ProtocolType')
          if self.hasContent_():
              lwrite('>')
              lwrite(quote_xml(self.valueOf_))
              self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print)
              lwrite('</%s%s>%s' % (namespace_, name_, eol_))
          else:
              lwrite('/>%s' % (eol_, ))
      def exportAttributes(self, lwrite, level, already_processed, namespace_='PortObj:', name_='Layer4ProtocolType'):
          super(Layer4ProtocolType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='Layer4ProtocolType')
          if self.datatype is not None:
  
              lwrite(' datatype=%s' % (quote_attrib(self.datatype), ))
      def exportChildren(self, lwrite, level, namespace_='PortObj:', name_='Layer4ProtocolType', fromsubclass_=False, pretty_print=True):
          super(Layer4ProtocolType, self).exportChildren(lwrite, level, 'PortObj:', name_, True, pretty_print=pretty_print)
          pass
      def build(self, node):
          self.__sourcenode__ = node
          already_processed = set()
          self.buildAttributes(node, node.attrib, already_processed)
          self.valueOf_ = get_all_text_(node)
          for child in node:
              nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
              self.buildChildren(child, node, nodeName_)
      def buildAttributes(self, node, attrs, already_processed):
          value = find_attr_value_('datatype', node)
          if value is not None:
  
              self.datatype = value
          super(Layer4ProtocolType, self).buildAttributes(node, attrs, already_processed)
      def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
          pass
  # end class Layer4ProtocolType
  
  class PortObjectType(cybox_common.ObjectPropertiesType):
      """The PortObjectType type is intended to characterize networking
      ports."""
  
      subclass = None
      superclass = cybox_common.ObjectPropertiesType
      def __init__(self, object_reference=None, Custom_Properties=None, xsi_type=None, Port_Value=None, Layer4_Protocol=None):
          super(PortObjectType, self).__init__(object_reference, Custom_Properties, xsi_type )
          self.Port_Value = Port_Value
          self.Layer4_Protocol = Layer4_Protocol
      def factory(*args_, **kwargs_):
          if PortObjectType.subclass:
              return PortObjectType.subclass(*args_, **kwargs_)
          else:
              return PortObjectType(*args_, **kwargs_)
      factory = staticmethod(factory)
      def get_Port_Value(self): return self.Port_Value
      def set_Port_Value(self, Port_Value): self.Port_Value = Port_Value
      def validate_PositiveIntegerObjectPropertyType(self, value):
          # Validate type cybox_common.PositiveIntegerObjectPropertyType, a restriction on None.
          pass
      def get_Layer4_Protocol(self): return self.Layer4_Protocol
      def set_Layer4_Protocol(self, Layer4_Protocol): self.Layer4_Protocol = Layer4_Protocol
      def validate_Layer4ProtocolType(self, value):
          # Validate type Layer4ProtocolType, a restriction on None.
          pass
      def hasContent_(self):
          if (
              self.Port_Value is not None or
              self.Layer4_Protocol is not None or
              super(PortObjectType, self).hasContent_()
              ):
              return True
          else:
              return False
      def export(self, lwrite, level, namespace_='PortObj:', name_='PortObjectType', namespacedef_='', pretty_print=True):
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          showIndent(lwrite, level, pretty_print)
          lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
          already_processed = set()
          self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PortObjectType')
          if self.hasContent_():
              lwrite('>%s' % (eol_, ))
              self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print)
              showIndent(lwrite, level, pretty_print)
              lwrite('</%s%s>%s' % (namespace_, name_, eol_))
          else:
              lwrite('/>%s' % (eol_, ))
      def exportAttributes(self, lwrite, level, already_processed, namespace_='PortObj:', name_='PortObjectType'):
          super(PortObjectType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='PortObjectType')
      def exportChildren(self, lwrite, level, namespace_='PortObj:', name_='PortObjectType', fromsubclass_=False, pretty_print=True):
          super(PortObjectType, self).exportChildren(lwrite, level, 'PortObj:', name_, True, pretty_print=pretty_print)
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          if self.Port_Value is not None:
              self.Port_Value.export(lwrite, level, 'PortObj:', name_='Port_Value', pretty_print=pretty_print)
          if self.Layer4_Protocol is not None:
              self.Layer4_Protocol.export(lwrite, level, 'PortObj:', name_='Layer4_Protocol', pretty_print=pretty_print)
      def build(self, node):
          self.__sourcenode__ = node
          already_processed = set()
          self.buildAttributes(node, node.attrib, already_processed)
          for child in node:
              nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
              self.buildChildren(child, node, nodeName_)
      def buildAttributes(self, node, attrs, already_processed):
          super(PortObjectType, self).buildAttributes(node, attrs, already_processed)
      def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
          if nodeName_ == 'Port_Value':
              obj_ = cybox_common.PositiveIntegerObjectPropertyType.factory()
              obj_.build(child_)
              self.set_Port_Value(obj_)
          elif nodeName_ == 'Layer4_Protocol':
              obj_ = Layer4ProtocolType.factory()
              obj_.build(child_)
              self.set_Layer4_Protocol(obj_)
          super(PortObjectType, self).buildChildren(child_, node, nodeName_, True)
  # end class PortObjectType
  
  GDSClassesMapping = {
      'Build_Utility': cybox_common.BuildUtilityType,
      'Errors': cybox_common.ErrorsType,
      'Time': cybox_common.TimeType,
      'Certificate_Issuer': cybox_common.StringObjectPropertyType,
      'Metadata': cybox_common.MetadataType,
      'Hash': cybox_common.HashType,
      'Information_Source_Type': cybox_common.ControlledVocabularyStringType,
      'Block_Hash_Value': cybox_common.HashValueType,
      'Fuzzy_Hash_Structure': cybox_common.FuzzyHashStructureType,
      'SubDatum': cybox_common.MetadataType,
      'Segment_Hash': cybox_common.HashValueType,
      'Digital_Signature': cybox_common.DigitalSignatureInfoType,
      'Code_Snippets': cybox_common.CodeSnippetsType,
      'Value': cybox_common.StringObjectPropertyType,
      'Length': cybox_common.IntegerObjectPropertyType,
      'Encoding': cybox_common.ControlledVocabularyStringType,
      'Internationalization_Settings': cybox_common.InternationalizationSettingsType,
      'Tool_Configuration': cybox_common.ToolConfigurationType,
      'English_Translation': cybox_common.StringObjectPropertyType,
      'Functions': cybox_common.FunctionsType,
      'String_Value': cybox_common.StringObjectPropertyType,
      'Build_Utility_Platform_Specification': cybox_common.PlatformSpecificationType,
      'Compiler_Informal_Description': cybox_common.CompilerInformalDescriptionType,
      'System': cybox_common.ObjectPropertiesType,
      'Platform': cybox_common.PlatformSpecificationType,
      'Usage_Context_Assumptions': cybox_common.UsageContextAssumptionsType,
      'Type': cybox_common.ControlledVocabularyStringType,
      'Compilers': cybox_common.CompilersType,
      'Tool_Type': cybox_common.ControlledVocabularyStringType,
      'String': cybox_common.ExtractedStringType,
      'Custom_Properties': cybox_common.CustomPropertiesType,
      'Build_Information': cybox_common.BuildInformationType,
      'Tool_Hashes': cybox_common.HashListType,
      'Compiler_Platform_Specification': cybox_common.PlatformSpecificationType,
      'Error_Instances': cybox_common.ErrorInstancesType,
      'Data_Segment': cybox_common.StringObjectPropertyType,
      'Certificate_Subject': cybox_common.StringObjectPropertyType,
      'Language': cybox_common.StringObjectPropertyType,
      'Identifier': cybox_common.PlatformIdentifierType,
      'Strings': cybox_common.ExtractedStringsType,
      'Contributors': cybox_common.PersonnelType,
      'Reference_Description': cybox_common.StructuredTextType,
      'Code_Snippet': cybox_common.ObjectPropertiesType,
      'Configuration_Settings': cybox_common.ConfigurationSettingsType,
      'Simple_Hash_Value': cybox_common.SimpleHashValueType,
      'Byte_String_Value': cybox_common.HexBinaryObjectPropertyType,
      'Instance': cybox_common.ObjectPropertiesType,
      'Import': cybox_common.StringObjectPropertyType,
      'Property': cybox_common.PropertyType,
      'Tool_Specific_Data': cybox_common.ToolSpecificDataType,
      'Execution_Environment': cybox_common.ExecutionEnvironmentType,
      'Dependencies': cybox_common.DependenciesType,
      'Offset': cybox_common.IntegerObjectPropertyType,
      'Date': cybox_common.DateRangeType,
      'Hashes': cybox_common.HashListType,
      'Segments': cybox_common.HashSegmentsType,
      'Segment_Count': cybox_common.IntegerObjectPropertyType,
      'Usage_Context_Assumption': cybox_common.StructuredTextType,
      'Block_Hash': cybox_common.FuzzyHashBlockType,
      'Dependency': cybox_common.DependencyType,
      'Error': cybox_common.ErrorType,
      'Trigger_Point': cybox_common.HexBinaryObjectPropertyType,
      'Environment_Variable': cybox_common.EnvironmentVariableType,
      'Byte_Run': cybox_common.ByteRunType,
      'File_System_Offset': cybox_common.IntegerObjectPropertyType,
      'Image_Offset': cybox_common.IntegerObjectPropertyType,
      'Imports': cybox_common.ImportsType,
      'Library': cybox_common.LibraryType,
      'References': cybox_common.ToolReferencesType,
      'Internal_Strings': cybox_common.InternalStringsType,
      'Configuration_Setting': cybox_common.ConfigurationSettingType,
      'Libraries': cybox_common.LibrariesType,
      'Function': cybox_common.StringObjectPropertyType,
      'Description': cybox_common.StructuredTextType,
      'User_Account_Info': cybox_common.ObjectPropertiesType,
      'Build_Configuration': cybox_common.BuildConfigurationType,
      'Address': cybox_common.HexBinaryObjectPropertyType,
      'Search_Within': cybox_common.IntegerObjectPropertyType,
      'Segment': cybox_common.HashSegmentType,
      'Port_Value': cybox_common.PositiveIntegerObjectPropertyType,
      'Compiler': cybox_common.CompilerType,
      'Name': cybox_common.StringObjectPropertyType,
      'Signature_Description': cybox_common.StringObjectPropertyType,
      'Block_Size': cybox_common.IntegerObjectPropertyType,
      'Search_Distance': cybox_common.IntegerObjectPropertyType,
      'Fuzzy_Hash_Value': cybox_common.FuzzyHashValueType,
      'Data_Size': cybox_common.DataSizeType,
      'Dependency_Description': cybox_common.StructuredTextType,
      'Contributor': cybox_common.ContributorType,
      'Tools': cybox_common.ToolsInformationType,
      'Tool': cybox_common.ToolInformationType,
  }
  
  USAGE_TEXT = """
  Usage: python <Parser>.py [ -s ] <in_xml_file>
  """
  
  def usage():
      print(USAGE_TEXT)
      sys.exit(1)
  
  def get_root_tag(node):
      tag = Tag_pattern_.match(node.tag).groups()[-1]
      rootClass = GDSClassesMapping.get(tag)
      if rootClass is None:
          rootClass = globals().get(tag)
      return tag, rootClass
  
  def parse(inFileName):
      doc = parsexml_(inFileName)
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Port'
          rootClass = PortObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
  #    sys.stdout.write('<?xml version="1.0" ?>\n')
  #    rootObj.export(sys.stdout.write, 0, name_=rootTag,
  #        namespacedef_='',
  #        pretty_print=True)
      return rootObj
  
  def parseEtree(inFileName):
      doc = parsexml_(inFileName)
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Port'
          rootClass = PortObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
      rootElement = rootObj.to_etree(None, name_=rootTag)
      content = etree_.tostring(rootElement, pretty_print=True,
          xml_declaration=True, encoding="utf-8")
      sys.stdout.write(content)
      sys.stdout.write('\n')
      return rootObj, rootElement
  
  def parseString(inString):
      from mixbox.vendor.six import StringIO
      doc = parsexml_(StringIO(inString))
      rootNode = doc.getroot()
      rootTag, rootClass = get_root_tag(rootNode)
      if rootClass is None:
          rootTag = 'Port'
          rootClass = PortObjectType
      rootObj = rootClass.factory()
      rootObj.build(rootNode)
      # Enable Python to collect the space used by the DOM.
      doc = None
  #    sys.stdout.write('<?xml version="1.0" ?>\n')
  #    rootObj.export(sys.stdout.write, 0, name_="Port",
  #        namespacedef_='')
      return rootObj
  
  def main():
      args = sys.argv[1:]
      if len(args) == 1:
          parse(args[0])
      else:
          usage()
  
  if __name__ == '__main__':
      #import pdb; pdb.set_trace()
      main()
  
  __all__ = [
      "PortObjectType",
      "Layer4ProtocolType"
      ]
  