Inheritance diagram for scripts.database.Database:

Public Member Functions
	__init__ (self, root_dir)

	Clone (self)

	Delete (self)

	Load (self)

	Cache (self)

	LoadFromCache (self)

	Save (self)

	HasInterface (self, interface_name)

	GetInterface (self, interface_name)

	AddInterface (self, interface)

	GetInterfaces (self)

	DeleteInterface (self, interface_name)

	Hierarchy (self, interface)

	HasEnum (self, enum_name)

	GetEnum (self, enum_name)

	AddEnum (self, enum)

	HasDictionary (self, dictionary_name)

	GetDictionary (self, dictionary_name)

	AddDictionary (self, dictionary)

	GetDictionaries (self)

	HasTypeDef (self, type_def_name)

	GetTypeDef (self, type_def_name)

	AddTypeDef (self, type_def)

	TransitiveSecondaryParents (self, interface, propagate_event_target)

Protected Member Functions
	_ScanForInterfaces (self)

	_FilePath (self, interface_name)

	_LoadInterfaceFile (self, interface_name)

	_SaveInterfaceFile (self, interface)

	_DeleteInterfaceFile (self, interface_name)

Protected Attributes
	_root_dir

	_all_interfaces

	_interfaces_to_delete

	_enums

	_all_dictionaries

	_all_type_defs

Detailed Description

The Database class manages a collection of IDL files stored
inside a directory.

Each IDL is describing a single interface. The IDL files are written in the
FremontCut syntax, which is derived from the Web IDL syntax and includes
annotations.

Database operations include adding, updating and removing IDL files.

Definition at line 20 of file database.py.

Constructor & Destructor Documentation

◆ init()

scripts.database.Database.__init__	(	self,
		root_dir
	)

Initializes a Database over a given directory.

Args:
root_dir -- a directory. If directory does not exist, it will
be created.

Definition at line 31 of file database.py.

    def __init__(self, root_dir):
        """Initializes a Database over a given directory.
 
    Args:
      root_dir -- a directory. If directory does not exist, it will
      be created.
    """
        self._root_dir = root_dir
        if not os.path.exists(root_dir):
            _logger.debug('creating root directory %s' % root_dir)
            os.makedirs(root_dir)
        self._all_interfaces = {}
        self._interfaces_to_delete = []
        self._enums = {}
        self._all_dictionaries = {}
        # TODO(terry): Hack to remember all typedef unions.
        self._all_type_defs = {}
 

Member Function Documentation

◆ _DeleteInterfaceFile()

scripts.database.Database._DeleteInterfaceFile	(	self,
		interface_name
	)

protected

Actual file deletion

Definition at line 228 of file database.py.

    def _DeleteInterfaceFile(self, interface_name):
        """Actual file deletion"""
        file_path = self._FilePath(interface_name)
        if os.path.exists(file_path):
            _logger.debug('deleting %s' % file_path)
            os.remove(file_path)
 

◆ _FilePath()

scripts.database.Database._FilePath	(	self,
		interface_name
	)

protected

Calculates the file path that a given interface should
be saved to.

Args:
interface_name -- the name of the interface.

Definition at line 85 of file database.py.

    def _FilePath(self, interface_name):
        """Calculates the file path that a given interface should
    be saved to.
 
    Args:
      interface_name -- the name of the interface.
    """
        return os.path.join(self._root_dir, '%s.idl' % interface_name)
 

◆ _LoadInterfaceFile()

scripts.database.Database._LoadInterfaceFile	(	self,
		interface_name
	)

protected

Loads an interface from the database.

Returns:
An IDLInterface instance or None if the interface is not found.
Args:
interface_name -- the name of the interface.

Definition at line 94 of file database.py.

    def _LoadInterfaceFile(self, interface_name):
        """Loads an interface from the database.
 
    Returns:
      An IDLInterface instance or None if the interface is not found.
    Args:
      interface_name -- the name of the interface.
    """
        file_name = self._FilePath(interface_name)
        _logger.info('loading %s' % file_name)
        if not os.path.exists(file_name):
            return None
 
        f = open(file_name, 'r')
        content = f.read()
        f.close()
 
        # Parse file:
        idl_file = idlnode.IDLFile(self._idlparser.parse(content), file_name)
 
        if not idl_file.interfaces:
            raise RuntimeError('No interface found in %s' % file_name)
        elif len(idl_file.interfaces) > 1:
            raise RuntimeError('Expected one interface in %s' % file_name)
 
        interface = idl_file.interfaces[0]
        self._all_interfaces[interface_name] = interface
        return interface
 

◆ _SaveInterfaceFile()

scripts.database.Database._SaveInterfaceFile	(	self,
		interface
	)

protected

Saves an interface into the database.

Args:
interface -- an IDLInterface instance.

Definition at line 157 of file database.py.

    def _SaveInterfaceFile(self, interface):
        """Saves an interface into the database.
 
    Args:
      interface -- an IDLInterface instance.
    """
 
        interface_name = interface.id
 
        # Actual saving
        file_path = self._FilePath(interface_name)
        _logger.debug('writing %s' % file_path)
 
        dir_name = os.path.dirname(file_path)
        if not os.path.exists(dir_name):
            _logger.debug('creating directory %s' % dir_name)
            os.mkdir(dir_name)
 
        # Render the IDLInterface object into text.
        text = idlrenderer.render(interface)
 
        f = open(file_path, 'w')
        f.write(text)
        f.close()
 

◆ _ScanForInterfaces()

scripts.database.Database._ScanForInterfaces ( self )

protected

Iterates over the database files and lists all interface names.

Return:
A list of interface names.

Definition at line 67 of file database.py.

    def _ScanForInterfaces(self):
        """Iterates over the database files and lists all interface names.
 
    Return:
      A list of interface names.
    """
        res = []
 
        def Visitor(_, dirname, names):
            for name in names:
                if os.path.isfile(os.path.join(dirname, name)):
                    root, ext = os.path.splitext(name)
                    if ext == '.idl':
                        res.append(root)
 
        os.path.walk(self._root_dir, Visitor, None)
        return res
 

◆ AddDictionary()

scripts.database.Database.AddDictionary	(	self,
		dictionary
	)

Returns an IDLDictionary corresponding to the dictionary_name
from memory.

Args:
dictionary -- the name of the dictionary.

Definition at line 269 of file database.py.

    def AddDictionary(self, dictionary):
        """Returns an IDLDictionary corresponding to the dictionary_name
    from memory.
 
    Args:
      dictionary -- the name of the dictionary.
    """
        dictionary_name = dictionary.id
        if dictionary_name in self._all_dictionaries:
            raise RuntimeError('Dictionary %s already exists' % dictionary_name)
        self._all_dictionaries[dictionary_name] = dictionary
 

◆ AddEnum()

scripts.database.Database.AddEnum	(	self,
		enum
	)

Definition at line 251 of file database.py.

    def AddEnum(self, enum):
        self._enums[enum.id] = enum
 

◆ AddInterface()

scripts.database.Database.AddInterface	(	self,
		interface
	)

Returns an IDLInterface corresponding to the interface_name
from memory.

Args:
interface -- the name of the interface.

Definition at line 197 of file database.py.

    def AddInterface(self, interface):
        """Returns an IDLInterface corresponding to the interface_name
    from memory.
 
    Args:
      interface -- the name of the interface.
    """
        interface_name = interface.id
        if interface_name in self._all_interfaces:
            raise RuntimeError('Interface %s already exists' % interface_name)
        self._all_interfaces[interface_name] = interface
 

◆ AddTypeDef()

scripts.database.Database.AddTypeDef	(	self,
		type_def
	)

Add only a typedef that a unions they map to any (no type).

Definition at line 303 of file database.py.

    def AddTypeDef(self, type_def):
        """Add only a typedef that a unions they map to any (no type)."""
        type_def_name = type_def.id
        if type_def_name in self._all_type_defs:
            raise RuntimeError('Typedef %s already exists' % type_def_name)
        self._all_type_defs[type_def_name] = type_def
        print('  Added typedef %s' % type_def_name)
 

◆ Cache()

scripts.database.Database.Cache ( self )

Serialize the database using pickle for faster startup in the future

Definition at line 131 of file database.py.

    def Cache(self):
        """Serialize the database using pickle for faster startup in the future
    """
        output_file = open(os.path.join(self._root_dir, 'cache.pickle'), 'wb')
        pickle.dump(self._all_interfaces, output_file)
        pickle.dump(self._interfaces_to_delete, output_file)
 

◆ Clone()

scripts.database.Database.Clone ( self )

Definition at line 49 of file database.py.

    def Clone(self):
        new_database = Database(self._root_dir)
        new_database._all_interfaces = copy.deepcopy(self._all_interfaces)
        new_database._interfaces_to_delete = copy.deepcopy(
            self._interfaces_to_delete)
        new_database._enums = copy.deepcopy(self._enums)
        new_database._all_dictionaries = copy.deepcopy(self._all_dictionaries)
        new_database._all_type_defs = copy.deepcopy(self._all_type_defs)
 
        return new_database
 

◆ Delete()

scripts.database.Database.Delete ( self )

Deletes the database by deleting its directory

Definition at line 60 of file database.py.

    def Delete(self):
        """Deletes the database by deleting its directory"""
        if os.path.exists(self._root_dir):
            shutil.rmtree(self._root_dir)
        # reset in-memory constructs
        self._all_interfaces = {}
 

◆ DeleteInterface()

scripts.database.Database.DeleteInterface	(	self,
		interface_name
	)

Deletes an interface from the database. File is deleted when
Save() is called.

Args:
interface_name -- the name of the interface.

Definition at line 216 of file database.py.

    def DeleteInterface(self, interface_name):
        """Deletes an interface from the database. File is deleted when
    Save() is called.
 
    Args:
      interface_name -- the name of the interface.
    """
        if interface_name not in self._all_interfaces:
            raise RuntimeError('Interface %s not found' % interface_name)
        self._interfaces_to_delete.append(interface_name)
        del self._all_interfaces[interface_name]
 

◆ GetDictionaries()

scripts.database.Database.GetDictionaries ( self )

Returns a list of all loaded dictionaries.

Definition at line 281 of file database.py.

    def GetDictionaries(self):
        """Returns a list of all loaded dictionaries."""
        res = []
        for _, dictionary in sorted(self._all_dictionaries.items()):
            res.append(dictionary)
        return res
 

◆ GetDictionary()

scripts.database.Database.GetDictionary	(	self,
		dictionary_name
	)

Returns an IDLDictionary corresponding to the dictionary_name
from memory.

Args:
dictionary_name -- the name of the dictionary.

Definition at line 258 of file database.py.

    def GetDictionary(self, dictionary_name):
        """Returns an IDLDictionary corresponding to the dictionary_name
    from memory.
 
    Args:
      dictionary_name -- the name of the dictionary.
    """
        if dictionary_name not in self._all_dictionaries:
            raise RuntimeError('Dictionary %s is not loaded' % dictionary_name)
        return self._all_dictionaries[dictionary_name]
 

◆ GetEnum()

scripts.database.Database.GetEnum	(	self,
		enum_name
	)

Definition at line 248 of file database.py.

    def GetEnum(self, enum_name):
        return self._enums[enum_name]
 

◆ GetInterface()

scripts.database.Database.GetInterface	(	self,
		interface_name
	)

Returns an IDLInterface corresponding to the interface_name
from memory.

Args:
interface_name -- the name of the interface.

Definition at line 186 of file database.py.

    def GetInterface(self, interface_name):
        """Returns an IDLInterface corresponding to the interface_name
    from memory.
 
    Args:
      interface_name -- the name of the interface.
    """
        if interface_name not in self._all_interfaces:
            raise RuntimeError('Interface %s is not loaded' % interface_name)
        return self._all_interfaces[interface_name]
 

◆ GetInterfaces()

scripts.database.Database.GetInterfaces ( self )

Returns a list of all loaded interfaces.

Definition at line 209 of file database.py.

    def GetInterfaces(self):
        """Returns a list of all loaded interfaces."""
        res = []
        for _, interface in sorted(self._all_interfaces.items()):
            res.append(interface)
        return res
 

◆ GetTypeDef()

scripts.database.Database.GetTypeDef	(	self,
		type_def_name
	)

Returns an IDLTypeDef corresponding to the type_def_name
from memory.

Args:
type_def_name -- the name of the typedef.

Definition at line 292 of file database.py.

    def GetTypeDef(self, type_def_name):
        """Returns an IDLTypeDef corresponding to the type_def_name
    from memory.
 
    Args:
      type_def_name -- the name of the typedef.
    """
        if type_def_name not in self._all_type_defs:
            raise RuntimeError('Typedef %s is not loaded' % type_def_name)
        return self._all_type_defs[type_def_name]
 

◆ HasDictionary()

scripts.database.Database.HasDictionary	(	self,
		dictionary_name
	)

Returns True if the dictionary is in memory

Definition at line 254 of file database.py.

    def HasDictionary(self, dictionary_name):
        """Returns True if the dictionary is in memory"""
        return dictionary_name in self._all_dictionaries
 

◆ HasEnum()

scripts.database.Database.HasEnum	(	self,
		enum_name
	)

Definition at line 245 of file database.py.

    def HasEnum(self, enum_name):
        return enum_name in self._enums
 

◆ HasInterface()

scripts.database.Database.HasInterface	(	self,
		interface_name
	)

Returns True if the interface is in memory

Definition at line 182 of file database.py.

    def HasInterface(self, interface_name):
        """Returns True if the interface is in memory"""
        return interface_name in self._all_interfaces
 

◆ HasTypeDef()

scripts.database.Database.HasTypeDef	(	self,
		type_def_name
	)

Returns True if the typedef is in memory

Definition at line 288 of file database.py.

    def HasTypeDef(self, type_def_name):
        """Returns True if the typedef is in memory"""
        return type_def_name in self._all_type_defs
 

◆ Hierarchy()

scripts.database.Database.Hierarchy	(	self,
		interface
	)

Definition at line 235 of file database.py.

    def Hierarchy(self, interface):
        yield interface
        for parent in interface.parents:
            parent_name = parent.type.id
            if not self.HasInterface(parent.type.id):
                continue
            for parent_interface in self.Hierarchy(
                    self.GetInterface(parent.type.id)):
                yield parent_interface
 

◆ Load()

scripts.database.Database.Load ( self )

Loads all interfaces into memory.

Definition at line 123 of file database.py.

    def Load(self):
        """Loads all interfaces into memory.
    """
        # FIXME: Speed this up by multi-threading.
        for (interface_name) in self._ScanForInterfaces():
            self._LoadInterfaceFile(interface_name)
        self.Cache()
 

◆ LoadFromCache()

scripts.database.Database.LoadFromCache ( self )

Deserialize the database using pickle for fast startup

Definition at line 138 of file database.py.

    def LoadFromCache(self):
        """Deserialize the database using pickle for fast startup
    """
        input_file_name = os.path.join(self._root_dir, 'cache.pickle')
        if not os.path.isfile(input_file_name):
            self.Load()
            return
        input_file = open(input_file_name, 'rb')
        self._all_interfaces = pickle.load(input_file)
        self._interfaces_to_delete = pickle.load(input_file)
        input_file.close()
 

◆ Save()

scripts.database.Database.Save ( self )

Saves all in-memory interfaces into files.

Definition at line 150 of file database.py.

    def Save(self):
        """Saves all in-memory interfaces into files."""
        for interface in list(self._all_interfaces.values()):
            self._SaveInterfaceFile(interface)
        for interface_name in self._interfaces_to_delete:
            self._DeleteInterfaceFile(interface_name)
 

◆ TransitiveSecondaryParents()

scripts.database.Database.TransitiveSecondaryParents	(	self,
		interface,
		propagate_event_target
	)

Returns a list of all non-primary parents.

The list contains the interface objects for interfaces defined in the
database, and the name for undefined interfaces.

Definition at line 311 of file database.py.

    def TransitiveSecondaryParents(self, interface, propagate_event_target):
        """Returns a list of all non-primary parents.
 
    The list contains the interface objects for interfaces defined in the
    database, and the name for undefined interfaces.
    """
 
        def walk(parents, walk_result):
            for parent in parents:
                parent_name = parent.type.id
                if IsDartCollectionType(parent_name):
                    if not (parent_name in walk_result):
                        walk_result.append(parent_name)
                    continue
                if self.HasInterface(parent_name):
                    parent_interface = self.GetInterface(parent_name)
                    if not (parent_interface in walk_result):
                        # Interface has multi-inherited don't add interfaces more than once
                        # to our parent result list.
                        walk_result.append(parent_interface)
                    walk(parent_interface.parents, walk_result)
            return walk_result
 
        result = []
        if interface.parents:
            parent = interface.parents[0]
            if (IsPureInterface(parent.type.id, self) or
                (propagate_event_target and parent.type.id == 'EventTarget')):
                result = walk(interface.parents, [])
            else:
                result = walk(interface.parents[1:], [])
 
        return result

Member Data Documentation

◆ _all_dictionaries

scripts.database.Database._all_dictionaries

protected

Definition at line 45 of file database.py.

◆ _all_interfaces

scripts.database.Database._all_interfaces

protected

Definition at line 42 of file database.py.

◆ _all_type_defs

scripts.database.Database._all_type_defs

protected

Definition at line 47 of file database.py.

◆ _enums

scripts.database.Database._enums

protected

Definition at line 44 of file database.py.

◆ _interfaces_to_delete

scripts.database.Database._interfaces_to_delete

protected

Definition at line 43 of file database.py.

◆ _root_dir

scripts.database.Database._root_dir

protected

Definition at line 38 of file database.py.

The documentation for this class was generated from the following file:

third_party/dart-lang/sdk/tools/dom/scripts/database.py

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _DeleteInterfaceFile()

◆ _FilePath()

◆ _LoadInterfaceFile()

◆ _SaveInterfaceFile()

◆ _ScanForInterfaces()

◆ AddDictionary()

◆ AddEnum()

◆ AddInterface()

◆ AddTypeDef()

◆ Cache()

◆ Clone()

◆ Delete()

◆ DeleteInterface()

◆ GetDictionaries()

◆ GetDictionary()

◆ GetEnum()

◆ GetInterface()

◆ GetInterfaces()

◆ GetTypeDef()

◆ HasDictionary()

◆ HasEnum()

◆ HasInterface()

◆ HasTypeDef()

◆ Hierarchy()

◆ Load()

◆ LoadFromCache()

◆ Save()

◆ TransitiveSecondaryParents()

Member Data Documentation

◆ _all_dictionaries

◆ _all_interfaces

◆ _all_type_defs

◆ _enums

◆ _interfaces_to_delete

◆ _root_dir

◆ init()