workspacelibrarydbwriter.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBREPCB_CORE_WORKSPACELIBRARYDBWRITER_H
#define LIBREPCB_CORE_WORKSPACELIBRARYDBWRITER_H
 
/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../fileio/filepath.h"
#include "../types/elementname.h"
#include "../types/simplestring.h"
#include "workspacelibrarydb.h"
 
#include <QtCore>
 
#include <optional>
 
/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {
 
class Attribute;
class Component;
class ComponentCategory;
class Device;
class Package;
class PackageCategory;
class SQLiteDatabase;
class Symbol;
class Uuid;
class Version;
 
/*******************************************************************************
 *  Class WorkspaceLibraryDbWriter
 ******************************************************************************/
 
class WorkspaceLibraryDbWriter final {
public:
  // Constructors / Destructor
  WorkspaceLibraryDbWriter() = delete;
  WorkspaceLibraryDbWriter(const WorkspaceLibraryDbWriter& other) = delete;
  WorkspaceLibraryDbWriter(const FilePath& librariesRoot, SQLiteDatabase& db);
  ~WorkspaceLibraryDbWriter() noexcept;
 
  // General Methods
 
  void createAllTables();
 
  void addInternalData(const QString& key, int value);
 
  int addLibrary(const FilePath& fp, const Uuid& uuid, const Version& version,
                 bool deprecated, const QByteArray& iconPng,
                 const QString& manufacturer);
 
  void updateLibrary(const FilePath& fp, const Uuid& uuid,
                     const Version& version, bool deprecated,
                     const QByteArray& iconPng, const QString& manufacturer);
 
  template <typename ElementType>
  int addElement(int libId, const FilePath& fp, const Uuid& uuid,
                 const Version& version, bool deprecated,
                 const QString& generatedBy) {
    static_assert(std::is_same<ElementType, Symbol>::value ||
                      std::is_same<ElementType, Package>::value ||
                      std::is_same<ElementType, Component>::value,
                  "Unsupported ElementType");
    return addElement(getElementTable<ElementType>(), libId, fp, uuid, version,
                      deprecated, generatedBy);
  }
 
  template <typename ElementType>
  int addCategory(int libId, const FilePath& fp, const Uuid& uuid,
                  const Version& version, bool deprecated,
                  const std::optional<Uuid>& parent) {
    static_assert(std::is_same<ElementType, ComponentCategory>::value ||
                      std::is_same<ElementType, PackageCategory>::value,
                  "Unsupported ElementType");
    return addCategory(getElementTable<ElementType>(), libId, fp, uuid, version,
                       deprecated, parent);
  }
 
  int addDevice(int libId, const FilePath& fp, const Uuid& uuid,
                const Version& version, bool deprecated,
                const QString& generatedBy, const Uuid& component,
                const Uuid& package);
 
  int addPart(int devId, const QString& mpn, const QString& manufacturer);
 
  int addPartAttribute(int partId, const Attribute& attribute);
 
  int addOrganization(int libId, const FilePath& fp, const Uuid& uuid,
                      const Version& version, bool deprecated,
                      const QByteArray& logoPng, const QUrl& url,
                      const QString& country, const QStringList& fabs,
                      const QStringList& shipping, bool isSponsor,
                      int priority);
 
  int addOrganizationPcbDesignRules(int orgId, const Uuid& uuid,
                                    const QString& name,
                                    const QString& description, const QUrl& url,
                                    int maxLayers);
 
  int addOrganizationOutputJob(int orgId,
                               WorkspaceLibraryDb::OutputJobKind kind,
                               const Uuid& uuid, const QString& type,
                               const QString& name);
 
  template <typename ElementType>
  void removeElement(const FilePath& fp) {
    removeElement(getElementTable<ElementType>(), fp);
  }
 
  template <typename ElementType>
  void removeAllElements() {
    removeAllElements(getElementTable<ElementType>());
  }
 
  template <typename ElementType>
  int addTranslation(int elementId, const QString& locale,
                     const std::optional<ElementName>& name,
                     const std::optional<QString>& description,
                     const std::optional<QString>& keywords) {
    return addTranslation(getElementTable<ElementType>(), elementId, locale,
                          name, description, keywords);
  }
 
  template <typename ElementType>
  void removeAllTranslations() {
    removeAllTranslations(getElementTable<ElementType>());
  }
 
  template <typename ElementType>
  int addToCategory(int elementId, const Uuid& category) {
    static_assert(std::is_same<ElementType, Symbol>::value ||
                      std::is_same<ElementType, Package>::value ||
                      std::is_same<ElementType, Component>::value ||
                      std::is_same<ElementType, Device>::value,
                  "Unsupported ElementType");
    return addToCategory(getElementTable<ElementType>(), elementId, category);
  }
 
  template <typename ElementType>
  int addResource(int elementId, const QString& name, const QString& mediaType,
                  const QUrl& url) {
    static_assert(std::is_same<ElementType, Component>::value ||
                      std::is_same<ElementType, Device>::value,
                  "Unsupported ElementType");
    return addResource(getElementTable<ElementType>(), elementId, name,
                       mediaType, url);
  }
 
  int addAlternativeName(int pkgId, const ElementName& name,
                         const SimpleString& reference);
 
  // Helper Functions
 
  template <typename ElementType>
  static QString getElementTable() noexcept;
 
  template <typename ElementType>
  static QString getCategoryTable() noexcept;
 
  // Operator Overloadings
  WorkspaceLibraryDbWriter& operator=(const WorkspaceLibraryDbWriter& rhs) =
      delete;
 
private:  // Methods
  int addElement(const QString& elementsTable, int libId, const FilePath& fp,
                 const Uuid& uuid, const Version& version, bool deprecated,
                 const QString& generatedBy);
  int addCategory(const QString& categoriesTable, int libId, const FilePath& fp,
                  const Uuid& uuid, const Version& version, bool deprecated,
                  const std::optional<Uuid>& parent);
  void removeElement(const QString& elementsTable, const FilePath& fp);
  void removeAllElements(const QString& elementsTable);
  int addTranslation(const QString& elementsTable, int elementId,
                     const QString& locale,
                     const std::optional<ElementName>& name,
                     const std::optional<QString>& description,
                     const std::optional<QString>& keywords);
  void removeAllTranslations(const QString& elementsTable);
  int addToCategory(const QString& elementsTable, int elementId,
                    const Uuid& category);
  int addResource(const QString& elementsTable, int elementId,
                  const QString& name, const QString& mediaType,
                  const QUrl& url);
  QString filePathToString(const FilePath& fp) const noexcept;
  static QString nonEmptyOrNull(const QString& s) noexcept;
  static QString nonNull(const QString& s) noexcept;
 
private:  // Data
  FilePath mLibrariesRoot;
  SQLiteDatabase& mDb;
};
 
/*******************************************************************************
 *  End of File
 ******************************************************************************/
 
}  // namespace librepcb
 
#endif