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
  from . import dns_record_object
  
  
  class DNSCacheEntryType(GeneratedsSuper):
      """The DNSCacheEntryType type is intended to characterize a single
      entry in a system's DNS cache."""
  
      subclass = None
      superclass = None
      def __init__(self, DNS_Entry=None, TTL=None):
          self.DNS_Entry = DNS_Entry
          self.TTL = TTL
      def factory(*args_, **kwargs_):
          if DNSCacheEntryType.subclass:
              return DNSCacheEntryType.subclass(*args_, **kwargs_)
          else:
              return DNSCacheEntryType(*args_, **kwargs_)
      factory = staticmethod(factory)
      def get_DNS_Entry(self): return self.DNS_Entry
      def set_DNS_Entry(self, DNS_Entry): self.DNS_Entry = DNS_Entry
      def get_TTL(self): return self.TTL
      def set_TTL(self, TTL): self.TTL = TTL
      def validate_PositiveIntegerObjectPropertyType(self, value):
          # Validate type cybox_common.PositiveIntegerObjectPropertyType, a restriction on None.
          pass
      def hasContent_(self):
          if (
              self.DNS_Entry is not None or
              self.TTL is not None
              ):
              return True
          else:
              return False
      def export(self, lwrite, level, namespace_='DNSCacheObj:', name_='DNSCacheEntryType', 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_='DNSCacheEntryType')
          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_='DNSCacheObj:', name_='DNSCacheEntryType'):
          pass
      def exportChildren(self, lwrite, level, namespace_='DNSCacheObj:', name_='DNSCacheEntryType', fromsubclass_=False, pretty_print=True):
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          if self.DNS_Entry is not None:
              self.DNS_Entry.export(lwrite, level, 'DNSCacheObj:', name_='DNS_Entry', pretty_print=pretty_print)
          if self.TTL is not None:
              self.TTL.export(lwrite, level, 'DNSCacheObj:', name_='TTL', 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):
          pass
      def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
          if nodeName_ == 'DNS_Entry':
              obj_ = dns_record_object.DNSRecordObjectType.factory()
              obj_.build(child_)
              self.set_DNS_Entry(obj_)
          elif nodeName_ == 'TTL':
              obj_ = cybox_common.PositiveIntegerObjectPropertyType.factory()
              obj_.build(child_)
              self.set_TTL(obj_)
  # end class DNSCacheEntryType
  
  class DNSCacheObjectType(cybox_common.ObjectPropertiesType):
      """The DNSCacheObjectType type is intended to characterize entries in a
      system's DNS cache."""
  
      subclass = None
      superclass = cybox_common.ObjectPropertiesType
      def __init__(self, object_reference=None, Custom_Properties=None, xsi_type=None, DNS_Cache_Entry=None):
          super(DNSCacheObjectType, self).__init__(object_reference, Custom_Properties, xsi_type )
          if DNS_Cache_Entry is None:
              self.DNS_Cache_Entry = []
          else:
              self.DNS_Cache_Entry = DNS_Cache_Entry
      def factory(*args_, **kwargs_):
          if DNSCacheObjectType.subclass:
              return DNSCacheObjectType.subclass(*args_, **kwargs_)
          else:
              return DNSCacheObjectType(*args_, **kwargs_)
      factory = staticmethod(factory)
      def get_DNS_Cache_Entry(self): return self.DNS_Cache_Entry
      def set_DNS_Cache_Entry(self, DNS_Cache_Entry): self.DNS_Cache_Entry = DNS_Cache_Entry
      def add_DNS_Cache_Entry(self, value): self.DNS_Cache_Entry.append(value)
      def insert_DNS_Cache_Entry(self, index, value): self.DNS_Cache_Entry[index] = value
      def hasContent_(self):
          if (
              self.DNS_Cache_Entry or
              super(DNSCacheObjectType, self).hasContent_()
              ):
              return True
          else:
              return False
      def export(self, lwrite, level, namespace_='DNSCacheObj:', name_='DNSCacheObjectType', 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_='DNSCacheObjectType')
          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_='DNSCacheObj:', name_='DNSCacheObjectType'):
          super(DNSCacheObjectType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DNSCacheObjectType')
      def exportChildren(self, lwrite, level, namespace_='DNSCacheObj:', name_='DNSCacheObjectType', fromsubclass_=False, pretty_print=True):
          super(DNSCacheObjectType, self).exportChildren(lwrite, level, 'DNSCacheObj:', name_, True, pretty_print=pretty_print)
          if pretty_print:
              eol_ = '\n'
          else:
              eol_ = ''
          for DNS_Cache_Entry_ in self.DNS_Cache_Entry:
              DNS_Cache_Entry_.export(lwrite, level, 'DNSCacheObj:', name_='DNS_Cache_Entry', 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(DNSCacheObjectType, self).buildAttributes(node, attrs, already_processed)
      def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
          if nodeName_ == 'DNS_Cache_Entry':
              obj_ = DNSCacheEntryType.factory()
              obj_.build(child_)
              self.DNS_Cache_Entry.append(obj_)
          super(DNSCacheObjectType, self).buildChildren(child_, node, nodeName_, True)
  # end class DNSCacheObjectType
  
  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,
      'Entry_Type': cybox_common.StringObjectPropertyType,
      'Information_Source_Type': cybox_common.ControlledVocabularyStringType,
      'Block_Hash_Value': cybox_common.HashValueType,
      'Fuzzy_Hash_Structure': cybox_common.FuzzyHashStructureType,
      'SubDatum': cybox_common.MetadataType,
      'Record_Name': cybox_common.StringObjectPropertyType,
      'Segment_Hash': cybox_common.HashValueType,
      'Digital_Signature': cybox_common.DigitalSignatureInfoType,
      'Code_Snippets': cybox_common.CodeSnippetsType,
      'Value': cybox_common.AnyURIObjectPropertyType,
      'Length': cybox_common.IntegerObjectPropertyType,
      'Encoding': cybox_common.ControlledVocabularyStringType,
      'Internationalization_Settings': cybox_common.InternationalizationSettingsType,
      'Tool_Configuration': cybox_common.ToolConfigurationType,
      'DNS_Entry': dns_record_object.DNSRecordObjectType,
      'English_Translation': cybox_common.StringObjectPropertyType,
      'DNS_Record': dns_record_object.DNSRecordObjectType,
      '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,
      'Tool': cybox_common.ToolInformationType,
      'Build_Information': cybox_common.BuildInformationType,
      'Tool_Hashes': cybox_common.HashListType,
      'TTL': cybox_common.IntegerObjectPropertyType,
      '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,
      'Property': cybox_common.PropertyType,
      'Strings': cybox_common.ExtractedStringsType,
      'Address_Class': cybox_common.StringObjectPropertyType,
      'File_System_Offset': cybox_common.IntegerObjectPropertyType,
      '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,
      'Record_Type': cybox_common.StringObjectPropertyType,
      'Instance': cybox_common.ObjectPropertiesType,
      'Import': cybox_common.StringObjectPropertyType,
      'Identifier': cybox_common.PlatformIdentifierType,
      '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,
      'Contributors': cybox_common.PersonnelType,
      'Image_Offset': cybox_common.IntegerObjectPropertyType,
      'Imports': cybox_common.ImportsType,
      'Library': cybox_common.LibraryType,
      'References': cybox_common.ToolReferencesType,
      'Internal_Strings': cybox_common.InternalStringsType,
      'Custom_Properties': cybox_common.CustomPropertiesType,
      'Configuration_Setting': cybox_common.ConfigurationSettingType,
      'Libraries': cybox_common.LibrariesType,
      'Function': cybox_common.StringObjectPropertyType,
      'Description': cybox_common.StructuredTextType,
      'Build_Configuration': cybox_common.BuildConfigurationType,
      'VLAN_Name': cybox_common.StringObjectPropertyType,
      'Search_Within': cybox_common.IntegerObjectPropertyType,
      'Segment': cybox_common.HashSegmentType,
      'Compiler': cybox_common.CompilerType,
      'Name': cybox_common.StringObjectPropertyType,
      'Address_Value': cybox_common.StringObjectPropertyType,
      'VLAN_Num': cybox_common.IntegerObjectPropertyType,
      'Flags': cybox_common.HexBinaryObjectPropertyType,
      'Signature_Description': cybox_common.StringObjectPropertyType,
      'Block_Size': cybox_common.IntegerObjectPropertyType,
      'Search_Distance': cybox_common.IntegerObjectPropertyType,
      'Data_Length': cybox_common.IntegerObjectPropertyType,
      'Fuzzy_Hash_Value': cybox_common.FuzzyHashValueType,
      'Dependency_Description': cybox_common.StructuredTextType,
      'Contributor': cybox_common.ContributorType,
      'User_Account_Info': cybox_common.ObjectPropertiesType,
      'Tools': cybox_common.ToolsInformationType,
      'Data_Size': cybox_common.DataSizeType,
  }
  
  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 = 'DNS_Cache'
          rootClass = DNSCacheObjectType
      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 = 'DNS_Cache'
          rootClass = DNSCacheObjectType
      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 = 'DNS_Cache'
          rootClass = DNSCacheObjectType
      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_="DNS_Cache",
  #        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__ = [
      "DNSCacheObjectType",
      "DNSCacheEntryType"
      ]
  