/*

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of SourcePawn.

  *

  * SourcePawn 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.

  * 

  * SourcePawn 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

  * SourcePawn. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_sp2_packages_h_

 #define _include_sp2_packages_h_

 #include "PoolAllocator.h"

 #include "Objects.h"

 #include "HashTable.h"

 namespace ke {

 class String;

 class Module;

 class Package;

 class ImportStatement;

 class VirtualObjectVisitor;

 template <typename T> class List;

 struct PathComponent : PoolObject

 {

     PathComponent(ScopedRoot<String> *name, PathComponent *next)

       : name(*name),

         next(next)

     {

     }

     ScopedRoot<String> &name;

     PathComponent *next;

 };

 class Importable : public Object

 {

   public:

     Package *parent() {

         return parent_;

     }

     String *path() {

         return path_;

     }

     String *name() {

         return name_;

     }

     bool isModule() {

         return is(MapKind_Module);

     }

     bool isPackage() {

         return is(MapKind_Package);

     }

     static inline size_t offsetOfName() {

         return OFFSETOF(Importable, name_);

     }

     static inline size_t offsetOfParent() {

         return OFFSETOF(Importable, parent_);

     }

     static inline size_t offsetOfPath() {

         return OFFSETOF(Importable, path_);

     }

     static inline Importable *cast(Object *obj) {

         assert(!obj || obj->is(MapKind_Module) || obj->is(MapKind_Package));

         return reinterpret_cast<Importable *>(obj);

     }

   protected:

     Barriered<String> name_;

     Barriered<Package> parent_;

     Barriered<String> path_;

 };

 // A package is a single folder in the file system, and contains any number of

 // modules and sub-packages. The package hierarchy forms a tree. For simplicity

 // the root of the tree is an anonymous package that contains no modules.

 //

 // Each package in the package hierarchy has two components of path information:

 //   (1) Canonical path. This is a normalized path used to compute the paths of

 //       modules.

 //   (2) Name. This is the package's name as it would appear in a path

 //       component. It is optional.

 //

 // Packages may be "hidden", meaning that even if they have names, their name

 // is not accessible from any import statements. Packages may also be "jailed",

 // meaning that other names in the package are not visible to each other.

 //

 // Packages are created in a few ways:

 //

 //   (1) System Roots. A system root is a default search location for imports,

 //       and they are installed at the top-level of the hierarchy by the host

 //       application. A system root has a unique top-level name and path.

 //       System roots are always hidden.

 //

 //   (2) Imports. When importing, the package hierarchy may be extended as

 //       new paths are discovered. Packages discovered this way are never

 //       hidden or jailed.

 //

 //   (3) Via Package::New(), which creates an empty package. This can be used

 //       to create custom packages.

 class Package : public Importable

 {

   public:

     enum {

         Normal = 0,

         // These must match the flags in the public API for Package.

         Hidden = (1 << 0),

         Jailed = (1 << 1)

     };

   public:

     static Package *NewNormalized(Zone *zone,

                                   Handle<Package> parent,

                                   Handle<String> path,

                                   Handle<String> name,

                                   unsigned flags);

     static Package *New(Zone *zone,

                         Handle<Package> parent,

                         const char *path,

                         Handle<String> name,

                         unsigned flags);

     bool add(Zone *zone, Handle<Importable> component);

     bool hidden() {

         return !!(flags_ & Package::Hidden);

     }

     bool jailed() {

         return !!(flags_ & Package::Jailed);

     }

     void setNativeIdentity(void *identity) {

         nativeIdentity_ = identity;

     }

     void *getNativeIdentity() {

         return nativeIdentity_;

     }

     Importable *import(Handle<String> name);

     // Begin GC descriptor.

     static inline size_t offsetOfContents() {

         return OFFSETOF(Package, contents_);

     }

     // End GC descriptor.

     static inline Package *cast(Object *obj) {

         assert(!obj || obj->is(MapKind_Package));

         return reinterpret_cast<Package *>(obj);

     }

   private:

     unsigned flags_;

     Barriered<List<Importable> > contents_;

     void *nativeIdentity_;

 };

 class PackageCache

 {

   public:

     PackageCache(Zone *zone);

     ~PackageCache();

     bool initialize();

     bool findOrAdd(Handle<Package> package, PathComponent *path, Importable **out);

     void accept(VirtualObjectVisitor *visitor);

   private:

     bool import(Handle<Package> package, PathComponent *path, Importable **out);

     bool checkfs(Handle<Package> package, PathComponent *path, Importable **out);

   private:

     Zone *zone_;

     Vector<Unbarriered<Package> > roots_;

 };

 } // namespace ke

 #endif // _include_sp2_packages_h_