Work with data files

    // Create the path to the local vector tile package (.vtpk file).
    const QString myDocumentsFolder = QStandardPaths::standardLocations(
        QStandardPaths::DocumentsLocation).at(0);
    const QString tileCachePath(QDir::toNativeSeparators(myDocumentsFolder + "/PencilMapTiles.vtpk"));

    // Create a vector tile cache from the local data.
    VectorTileCache* vectorTileCache = new VectorTileCache(tileCachePath, this);

    // Use the tile cache to create an ArcGIS vector tiled layer.
    ArcGISVectorTiledLayer* arcgisVectorTiledLayer = new ArcGISVectorTiledLayer(vectorTileCache, this);

    // Create a new basemap from the ArcGIS vector tiled layer.
    Basemap* basemap = new Basemap(arcgisVectorTiledLayer, this);

    // Create a new map using the basemap.
    Map* map = new Map(basemap, this);

    // Set the map in the map view.
    m_mapView->setMap(map);

    // Create the path to the local package (.tpkx file).
    const QString myDocumentsFolder = QStandardPaths::standardLocations(
        QStandardPaths::DocumentsLocation).at(0);
    const QString tileCachePath(QDir::toNativeSeparators(myDocumentsFolder + "/StreetMapTiles.tpkx"));

    // Create a tile cache from the local data.
    TileCache* tileCache = new TileCache(tileCachePath, this);

    // Use the tile cache to create an ArcGIS tiled layer.
    ArcGISTiledLayer* arcgisTiledLayer = new ArcGISTiledLayer(tileCache, this);

    // Create a new basemap from the ArcGIS tiled layer.
    Basemap* basemap = new Basemap(arcgisTiledLayer, this);

    // Create a new map using the basemap.
    Map* map = new Map(basemap, this);

    // Set the map in the map view.
    m_mapView->setMap(map);

    // Create the path to the local tile cache file (.tpkx).
    const QString myDocumentsFolder = QStandardPaths::standardLocations(
        QStandardPaths::DocumentsLocation).at(0);
    const QString tileCachePath(QDir::toNativeSeparators(myDocumentsFolder + "/WorldElevation3DTiles.tpkx"));

    // Create a tile cache from the local data.
    TileCache* tileCache = new TileCache(tileCachePath, this);

    // Use the tile cache to create an ArcGIS tiled elevation source.
    ArcGISTiledElevationSource* arcgisTiledElevationSource = new ArcGISTiledElevationSource(tileCache, this);

    // Connect to the ArcGIS tiled elevation source's done loading event.
    connect(arcgisTiledElevationSource, &ArcGISTiledElevationSource::doneLoading, this,
        [this, arcgisTiledElevationSource](Error e)
    {
        // Test for any errors and broadcast it.
        if (!e.isEmpty())
        {
            qDebug() << e.message() << ": " << e.additionalMessage();
        }

        // Create a new surface (default constructor).
        Surface* surface = new Surface(this);

        // Set the elevation exaggeration (2.0) on the surface.
        surface->setElevationExaggeration(2.0);

        // Get the elevation source list model from the surface.
        ElevationSourceListModel* elevationSourceListModel = surface->elevationSources();

        // Append the ArcGIS tiled elevation source to the elevation source list model.
        elevationSourceListModel->append(arcgisTiledElevationSource);

        // Create a new scene using the 'ArcGIS Community' base map style.
        Scene* scene = new Scene(BasemapStyle::ArcGISCommunity, this);

        // Set the base surface on the scene.
        scene->setBaseSurface(surface);

        // Set the gloabal scope scene to the scene.
        m_scene = scene;

        // Set the scene in the scene view.
        m_sceneView->setArcGISScene(scene);
    });

    // Call the load event on the ArcGIS tiled elevation source.
    arcgisTiledElevationSource->load();

    // Get the path to a local geodatabase.
    const QString myDocumentsFolder = QStandardPaths::standardLocations(QStandardPaths::TempLocation).at(0);
    const QString geodatabasePath(QDir::toNativeSeparators(myDocumentsFolder + "/recreation.geodatabase"));

    // Open the geodatabase if the file exists at the specified path.
    if (QFile(geodatabasePath).exists())
    {
        // Get the geodatabase using the path.
        Geodatabase* geodatabase = new Geodatabase(geodatabasePath, this);

        // Connect to the geodatabase's done loading event.
        connect(geodatabase, &Geodatabase::doneLoading, this, [this, geodatabase](Error loadError)
        {
            // Test for any errors and broadcast it.
            if (!loadError.isEmpty())
            {
                qDebug() << "Geodatabase load error: " << loadError.message() << " : " <<
                    loadError.additionalMessage();
            }

            // Access one of the feature tables in the geodatabase using its name ("Trailheads").
            GeodatabaseFeatureTable* geodatabaseFeatureTable = geodatabase->
                geodatabaseFeatureTable("Trailheads");

            // Create a new feature layer from the geodatabase feature table.
            FeatureLayer* featureLayer = new FeatureLayer(geodatabaseFeatureTable);

            // Get the layer list model from the map's operational layers.
            LayerListModel* layerListModel = m_map->operationalLayers();

            // Add the feature layer to the layer list model (causing the layer to display).
            layerListModel->append(featureLayer);
        });

        // Call the geodatabase load event.
        geodatabase->load();
    }
    else // If the geodatabase doesn't exist, create it.
    {
        // Execute the static geodatabase create async method using the supplied path and returning
        // a new geodatabase.
        Geodatabase::createAsync(geodatabasePath, this).then(this, [this](Geodatabase* geodatabase)
        {
            // Create a new range domain description in the geodatabase for rating values from 1-10.
            RangeDomainDescription* rangeDomainDescription = new RangeDomainDescription
                (
                    "RatingDomain", // range domain name
                    FieldType::Int16, // rage domain field type
                    QVariant(1), // minimum value - QVariant
                    QVariant(10), // maximum value - QVariant
                    this // parent
                );

            // Execute the geodatabase's create domain async method using the supplied
            // range domain description.
            geodatabase->createDomainAsync(rangeDomainDescription).then(this,
                [this, geodatabase](Domain domain)
            {
                // Create a new table description for a "Trailheads" table that will store points.
                TableDescription* tableDescription = new TableDescription
                    (
                        "Trailheads", // table name
                        SpatialReference::wgs84(), // table spatial reference
                        GeometryType::Point // table geometry type
                    );

                // Create a new field description to define the "Name" field.
                FieldDescription* fieldDescription = new FieldDescription
                    (
                        "Name", // field name
                        FieldType::Text, // field data type
                        this // parent
                    );

                // Get the field description list model from the table description.
                FieldDescriptionListModel* fieldDescriptionListModel = tableDescription->fieldDescriptions();

                // Add the field description to the field description list model.
                fieldDescriptionListModel->append(fieldDescription);

                // Create a new field description to define the "Difficulty" field.
                FieldDescription* difficultyFieldDescription = new FieldDescription
                    (
                        "Difficulty", // field name
                        FieldType::Int16, // field data type
                        this // parent
                    );

                // Set the domain name of "RatingDomain" for the difficulty field description.
                difficultyFieldDescription->setDomainName("RatingDomain");

                // Add the field description to the field descripton list model.
                fieldDescriptionListModel->append(difficultyFieldDescription);

                // Call the geodatabase's create table async method using the supplied table description.
                // The returned object is a geodatabase feature table.
                geodatabase->createTableAsync(tableDescription, this).then(this, [this]
                    (GeodatabaseFeatureTable* geodatabaseFeatureTable)
                {
                    // Create a new feature layer from the geodatabase feature table.
                    FeatureLayer* featureLayer = new FeatureLayer(geodatabaseFeatureTable);

                    // Get the map from the map view.
                    Map* map = m_mapView->map();

                    // Get the layer list model from the map's operational layers.
                    LayerListModel* layerListModel = map->operationalLayers();

                    // Add the feature layer to the layer list model.
                    layerListModel->append(featureLayer);
                });
            });
        });
    }

    // Get the path to a local GeoPackage (.gpkg file).
    const QString myDocumentsFolder = QStandardPaths::standardLocations(
        QStandardPaths::DocumentsLocation).at(0);
    const QString geopackagePath(QDir::toNativeSeparators(myDocumentsFolder + "/trails.gpkg"));

    // Create a new geopackage by providing the path.
    GeoPackage* geopackage = new GeoPackage(geopackagePath, this);

    // Connect to the geodatabase's done loading event.
    connect(geopackage, &GeoPackage::doneLoading, this, [this, geopackage](Error e)
    {
        // Get the QList of geopackage feature tables from the geopackage.
        const QList<GeoPackageFeatureTable*> geoPackageFeatureTables = geopackage->geoPackageFeatureTables();

        // Iterate over the geopackage feature tables in the QList.
        for (GeoPackageFeatureTable* geoPackageFeatureTable : geoPackageFeatureTables)
        {
            // Get the name of the table in the geopackage feature table.
            const QString tableName = geoPackageFeatureTable->tableName();

            // Test if the table name is "trailheads".
            if (tableName.toLower() == "trailheads")
            {
                // Create a new feature layer from the geopackage feature table.
                FeatureLayer* featureLayer = new FeatureLayer(geoPackageFeatureTable, this);

                // Get the map from the map view.
                Map* map = m_mapView->map();

                // Get the layer list model from the map's operational layers.
                LayerListModel* layerListModel = map->operationalLayers();

                // Add the feature layer to the layer list model.
                layerListModel->append(featureLayer);
            }
        }
    });

    // Call the goepackage's load function.
    geopackage->load();

    // Get the path to a local shapefile (.shp file).
    const QString myDocumentsFolder = QStandardPaths::standardLocations(
        QStandardPaths::DocumentsLocation).at(0);
    const QString shapefilePath(QDir::toNativeSeparators(myDocumentsFolder + "/trails.shp"));

    // Create a shapefile feature table using the path.
    ShapefileFeatureTable* shapefileFeatureTable = new ShapefileFeatureTable(shapefilePath, this);

    // Connect to the shapefile feature table's done loading event.
    connect(shapefileFeatureTable, &ShapefileFeatureTable::doneLoading, this,
        [this, shapefileFeatureTable](Error e)
    {
        // Test if we have any errors and broadcast it.
        if (!e.isEmpty())
        {
            qDebug() << e.message() << ": " << e.additionalMessage();
        }

        // Create a feature layer from the shapefile feature table.
        FeatureLayer* featureLayer = new FeatureLayer(shapefileFeatureTable);

        // Get the map from the map view.
        Map* map = m_mapView->map();

        // Get the layer list model from the map's operational layers.
        LayerListModel* layerListModel = map->operationalLayers();

        // Add the feature layer to the layer list model.
        layerListModel->append(featureLayer);
    });

    // Call the shapefile feature table load event.
    shapefileFeatureTable->load();