@aetherframework/middleware 1.0.2 → 1.0.4

package/src/core/AetherRouter.js

@@ -1,345 +1,447 @@
- /**
+/**
  * @license MIT
  * Copyright (c) 2026-present AetherFramework Contributors.
  * SPDX-License-Identifier: MIT
  * @module @aetherframework/middleware/core/AetherRouter
+ * 
+ * Ultra-Optimized Router for Maximum Performance
+ * Focus: Pure routing speed with zero overhead
  */
 
-import { EventEmitter } from "events";
+// [PERF] Pre-allocated frozen objects to prevent heap allocation in hot paths
+const EMPTY_PARAMS = Object.freeze({});
+const EMPTY_QUERY = Object.freeze({});
 
 /**
- * AetherRouter - High-performance routing system for AetherJS
- * Supports versioning, grouping, parameter parsing, and middleware chaining
+ * [PERF] Zero-Allocation Query Parser
  */
-class AetherRouter extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.routes = new Map(); // Store all routes: method+path -> handler
-    this.groups = new Map(); // Store route groups
-    this.middlewares = []; // Global middlewares
-    this.prefix = options.prefix || ""; // Route prefix
-    this.version = options.version || ""; // API version
-    
-    // Supported HTTP methods
-    this.methods = [
-      "GET", "POST", "PUT", "DELETE", 
-      "PATCH", "OPTIONS", "HEAD", "ANY"
-    ];
-    
-    // Initialize all HTTP method handlers
-    this.methods.forEach(method => {
-      this[method.toLowerCase()] = this._createRouteHandler(method);
-    });
+class JITQueryParser {
+  parse(search) {
+    if (!search || search.length === 0) return EMPTY_QUERY;
+
+    const query = {};
+    let i = 0;
+    const len = search.length;
     
-    // Special method: match any HTTP method
-    this.all = this._createRouteHandler("ANY");
+    while (i < len) {
+      let ampIndex = search.indexOf('&', i);
+      if (ampIndex === -1) ampIndex = len;
+      
+      const eqIndex = search.indexOf('=', i);
+      
+      if (eqIndex !== -1 && eqIndex < ampIndex) {
+        const rawKey = search.substring(i, eqIndex);
+        const rawValue = search.substring(eqIndex + 1, ampIndex);
+        const key = decodeURIComponent(rawKey);
+        const value = decodeURIComponent(rawValue);
+        
+        const kLen = key.length;
+        if (kLen > 2 && key.charCodeAt(kLen - 2) === 91 && key.charCodeAt(kLen - 1) === 93) {
+          const arrayKey = key.slice(0, -2);
+          let arr = query[arrayKey];
+          if (!arr) { arr = []; query[arrayKey] = arr; }
+          arr.push(value);
+        } else {
+          query[key] = value;
+        }
+      } else if (i < ampIndex) {
+        query[decodeURIComponent(search.substring(i, ampIndex))] = "";
+      }
+      
+      i = ampIndex + 1;
+    }
+    return query;
   }
+}
 
-  /**
-   * Create route handler for specific HTTP method
-   * @private
-   */
-  _createRouteHandler(method) {
-    return (path, ...handlers) => {
-      const fullPath = this._buildPath(path);
-      const route = {
-        method: method === "ANY" ? null : method,
-        path: fullPath,
-        handlers: this._wrapHandlers(handlers),
-        regex: this._pathToRegex(fullPath),
-        paramNames: this._extractParamNames(fullPath)
+/**
+ * [PERF] Optimized Handler Executor with Manual Loop Unrolling
+ */
+class JITHandlerExecutor {
+  getExecutor(handlers) {
+    const len = handlers.length;
+    if (len === 0) return this._exec0;
+    if (len === 1) return this._exec1;
+    if (len === 2) return this._exec2;
+    if (len === 3) return this._exec3;
+    if (len === 4) return this._exec4;
+    if (len === 5) return this._exec5;
+    
+    return async (context) => {
+      let index = 0;
+      const next = async () => {
+        if (index >= handlers.length || context.isTerminated()) return;
+        const handler = handlers[index++];
+        try {
+          await handler(context, next);
+        } catch (error) {
+          if (!context.isTerminated()) {
+            context.setStatus(500).json({ error: "Internal Server Error" });
+          }
+        }
       };
-      
-      const routeKey = `${method}:${fullPath}`;
-      this.routes.set(routeKey, route);
-      
-      this.emit("route:added", { method, path: fullPath, handlers: handlers.length });
-      return this;
+      await next();
     };
   }
 
-  /**
-   * Build full path with prefix and version
-   * @private
-   */
-  _buildPath(path) {
-    let fullPath = "";
+  async _exec0(ctx) {}
+  
+  // [FIX] 修复了 this 指向问题，this 现在是 handlers 数组
+  async _exec1(ctx) {
+    if (ctx.isTerminated()) return;
+    try { await this[0](ctx, async () => {}); } 
+    catch (e) { if (!ctx.isTerminated()) ctx.setStatus(500).json({ error: "Internal Server Error" }); }
+  }
+  
+  async _exec2(ctx) {
+    if (ctx.isTerminated()) return;
+    try { 
+      await this[0](ctx, async () => { 
+        if (!ctx.isTerminated()) await this[1](ctx, async () => {}); 
+      }); 
+    } catch (e) { if (!ctx.isTerminated()) ctx.setStatus(500).json({ error: "Internal Server Error" }); }
+  }
+  
+  async _exec3(ctx) {
+    if (ctx.isTerminated()) return;
+    try { 
+      await this[0](ctx, async () => { 
+        if (!ctx.isTerminated()) await this[1](ctx, async () => { 
+          if (!ctx.isTerminated()) await this[2](ctx, async () => {}); 
+        }); 
+      }); 
+    } catch (e) { if (!ctx.isTerminated()) ctx.setStatus(500).json({ error: "Internal Server Error" }); }
+  }
+  
+  async _exec4(ctx) {
+    if (ctx.isTerminated()) return;
+    try { 
+      await this[0](ctx, async () => { 
+        if (!ctx.isTerminated()) await this[1](ctx, async () => { 
+          if (!ctx.isTerminated()) await this[2](ctx, async () => { 
+            if (!ctx.isTerminated()) await this[3](ctx, async () => {}); 
+          }); 
+        }); 
+      }); 
+    } catch (e) { if (!ctx.isTerminated()) ctx.setStatus(500).json({ error: "Internal Server Error" }); }
+  }
+  
+  async _exec5(ctx) {
+    if (ctx.isTerminated()) return;
+    try { 
+      await this[0](ctx, async () => { 
+        if (!ctx.isTerminated()) await this[1](ctx, async () => { 
+          if (!ctx.isTerminated()) await this[2](ctx, async () => { 
+            if (!ctx.isTerminated()) await this[3](ctx, async () => { 
+              if (!ctx.isTerminated()) await this[4](ctx, async () => {}); 
+            }); 
+          }); 
+        }); 
+      }); 
+    } catch (e) { if (!ctx.isTerminated()) ctx.setStatus(500).json({ error: "Internal Server Error" }); }
+  }
+}
+
+class AetherRouter {
+  constructor(options = {}) {
+    this.staticRoutes = new Map(); 
+    this.dynamicRoutes = []; 
+    this.globalMiddlewares = [];
+    this.prefixMiddlewares = [];
+    this.prefix = options.prefix || "";
+    this.version = options.version || "";
+    this.routeCache = new Map();
+    this.cacheMaxSize = options.cacheMaxSize || 2000;
+    this.jitQueryParser = new JITQueryParser();
+    this.jitExecutor = new JITHandlerExecutor();
+  }
+
+  get(path, ...handlers) { return this._addRoute("GET", path, handlers); }
+  post(path, ...handlers) { return this._addRoute("POST", path, handlers); }
+  put(path, ...handlers) { return this._addRoute("PUT", path, handlers); }
+  delete(path, ...handlers) { return this._addRoute("DELETE", path, handlers); }
+  patch(path, ...handlers) { return this._addRoute("PATCH", path, handlers); }
+  options(path, ...handlers) { return this._addRoute("OPTIONS", path, handlers); }
+  head(path, ...handlers) { return this._addRoute("HEAD", path, handlers); }
+  all(path, ...handlers) { return this._addRoute("ANY", path, handlers); }
+
+  _addRoute(method, path, handlers) {
+    if (handlers.length === 0) throw new Error(`Route ${method} ${path} must have at least one handler`);
     
-    // Add version prefix
-    if (this.version) {
-      fullPath += `/v${this.version.replace(/[^0-9.]/g, "")}`;
-    }
+    const fullPath = this._buildPath(path);
+    const isStatic = fullPath.indexOf(':') === -1 && fullPath.indexOf('*') === -1;
     
-    // Add group prefix
-    if (this.prefix) {
-      fullPath += `/${this.prefix.replace(/^\/|\/$/g, "")}`;
-    }
+    const route = {
+      method: method === "ANY" ? null : method,
+      path: fullPath,
+      isStatic: isStatic,
+      handlers: this._wrapHandlers(handlers),
+      regex: isStatic ? null : this._pathToRegex(fullPath),
+      paramNames: isStatic ? [] : this._extractParamNames(fullPath)
+    };
     
-    // Add route path
+    if (isStatic) {
+      this.staticRoutes.set(`${route.method || 'ANY'}:${fullPath}`, route);
+    } else {
+      this.dynamicRoutes.push(route);
+    }
+    return this;
+  }
+
+  _buildPath(path) {
+    let fullPath = "";
+    if (this.version) fullPath += `/v${this.version.replace(/[^0-9.]/g, "")}`;
+    if (this.prefix) fullPath += `/${this.prefix.replace(/^\/|\/$/g, "")}`;
     fullPath += `/${path.replace(/^\/|\/$/g, "")}`;
-    
-    // Normalize path
     return fullPath.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
   }
 
-  /**
-   * Convert path pattern to regex
-   * @private
-   */
   _pathToRegex(path) {
-    const pattern = path
-      .replace(/:(\w+)/g, "(?<$1>[^/]+)") // Named parameters: :id
-      .replace(/\*(\w+)?/g, (_, name) => name ? `(?<${name}>.*)` : "(.*)") // Wildcards
-      .replace(/$([^)]+)$/g, "(?:$1)") // Optional groups
-      .replace(/\?/g, "\\?"); // Escape question marks
-    
+    const escapedPath = path.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const pattern = escapedPath
+      .replace(/\\:(\w+)/g, "([^/]+)") 
+      .replace(/\\*(\w+)?/g, "(.*)") 
+      .replace(/\\\?/g, "\\?");
     return new RegExp(`^${pattern}$`);
   }
 
-  /**
-   * Extract parameter names from path
-   * @private
-   */
+  // [FIX] 修复了 push(match) 导致推入整个 RegExp 数组的问题
   _extractParamNames(path) {
     const paramNames = [];
     const paramPattern = /:(\w+)/g;
     const wildcardPattern = /\*(\w+)?/g;
-    
     let match;
-    while ((match = paramPattern.exec(path)) !== null) {
-      paramNames.push(match);
-    }
-    
-    while ((match = wildcardPattern.exec(path)) !== null) {
-      if (match) paramNames.push(match);
-    }
-    
+    while ((match = paramPattern.exec(path)) !== null) paramNames.push(match[1]);
+    while ((match = wildcardPattern.exec(path)) !== null) if (match[1]) paramNames.push(match[1]);
     return paramNames;
   }
 
-  /**
-   * Wrap handlers with validation
-   * @private
-   */
   _wrapHandlers(handlers) {
-    return handlers.map(handler => {
-      if (typeof handler !== "function") {
-        throw new TypeError("Route handler must be a function");
+    for (let i = 0; i < handlers.length; i++) {
+      if (typeof handlers[i] !== "function") {
+        throw new TypeError(`Route handler must be a function, got ${typeof handlers[i]} at position ${i}`);
       }
-      return handler;
-    });
+    }
+    return handlers;
   }
 
-  /**
-   * Route grouping
-   * @param {string} prefix - Group prefix
-   * @param {Function} callback - Group definition function
-   */
   group(prefix, callback) {
-    const router = new AetherRouter({
-      prefix: `${this.prefix}/${prefix}`.replace(/\/+/g, "/"),
-      version: this.version
-    });
-    
-    // Inherit global middlewares
-    router.middlewares = [...this.middlewares];
-    
-    // Execute group definition
+    const router = new AetherRouter({ prefix: `${this.prefix}/${prefix}`.replace(/\/+/g, "/"), version: this.version });
+    router.globalMiddlewares = this.globalMiddlewares.slice();
+    router.prefixMiddlewares = this.prefixMiddlewares.slice();
     callback(router);
     
-    // Merge group routes into main router
-    router.routes.forEach((route, key) => {
-      this.routes.set(key, route);
-    });
+    router.staticRoutes.forEach((route, key) => this.staticRoutes.set(key, route));
+    for (let i = 0; i < router.dynamicRoutes.length; i++) this.dynamicRoutes.push(router.dynamicRoutes[i]);
+    return this;
+  }
+
+  version(version, callback) {
+    const router = new AetherRouter({ prefix: this.prefix, version: version });
+    router.globalMiddlewares = this.globalMiddlewares.slice();
+    router.prefixMiddlewares = this.prefixMiddlewares.slice();
+    callback(router);
     
+    router.staticRoutes.forEach((route, key) => this.staticRoutes.set(key, route));
+    for (let i = 0; i < router.dynamicRoutes.length; i++) this.dynamicRoutes.push(router.dynamicRoutes[i]);
     return this;
   }
 
-  /**
-   * API versioning
-   * @param {string} version - Version number (e.g., "1", "2.0")
-   * @param {Function} callback - Version definition function
-   */
- version(version, callback) {
-  const router = new AetherRouter({
-    prefix: this.prefix,
-    version: version
-  });
-  
-  // Inherit global middlewares
-  router.middlewares = [...this.middlewares];
-  
-  // Execute version definition
-  callback(router);
-  
-  // Merge version routes into main router
-  router.routes.forEach((route, key) => {
-    this.routes.set(key, route);
-  });
-  
-  return this;
-}
+  // [FIX] 重写了 use 方法，修复了 typeof args 永远为 'object' 的致命判断错误
+  use(...args) {
+    if (args.length === 0) return this;
+
+    if (typeof args[0] === 'string') {
+      const path = args[0];
+      const middlewares = args.slice(1);
+      
+      for (let i = 0; i < middlewares.length; i++) {
+        let mw = middlewares[i];
+        if (typeof mw !== "function") {
+          if (mw && typeof mw.middleware === 'function') middlewares[i] = mw.middleware();
+          else throw new TypeError(`Middleware for path "${path}" must be a function, got ${typeof mw}`);
+        }
+      }
+      
+      const normalizedPath = path === '/' ? '/' : path.replace(/\/+$/, '');
+      const escapedPath = normalizedPath.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+      const prefixRegex = normalizedPath === '/' ? null : new RegExp(`^${escapedPath}(?=/|$|\\?)`, 'i');
+      
+      const wrappedMiddlewares = new Array(middlewares.length);
+      for (let i = 0; i < middlewares.length; i++) {
+        const mw = middlewares[i];
+        wrappedMiddlewares[i] = async (ctx, next) => {
+          if (!prefixRegex) return mw(ctx, next);
+          const originalUrl = ctx.url;
+          const originalPath = ctx.path;
+          if (prefixRegex.test(originalUrl)) {
+            let newUrl = originalUrl.replace(prefixRegex, '');
+            if (newUrl.charCodeAt(0) !== 47) newUrl = '/' + newUrl;
+            ctx.url = newUrl;
+            try {
+              // [FIX] 修复了 split('?') 返回数组导致 ctx.path 类型错误的问题
+              if ('path' in ctx) ctx.path = newUrl.split('?')[0]; 
+              await mw(ctx, next);
+            } finally {
+              ctx.url = originalUrl;
+              if ('path' in ctx) ctx.path = originalPath;
+            }
+          } else { await next(); }
+        };
+      }
 
-  /**
-   * Add middleware to router
-   * @param {...Function} middlewares - Middleware functions
-   */
-  use(...middlewares) {
-    this.middlewares.push(...middlewares);
+      if (normalizedPath === '/') {
+        this.globalMiddlewares.push(...wrappedMiddlewares);
+      } else {
+        this.prefixMiddlewares.push({ path: normalizedPath, handlers: wrappedMiddlewares });
+      }
+    } else {
+      for (let i = 0; i < args.length; i++) {
+        if (typeof args[i] !== "function") throw new TypeError(`Global middleware must be a function, got ${typeof args[i]}`);
+      }
+      this.globalMiddlewares.push(...args);
+    }
     return this;
   }
 
-  /**
-   * Match route for incoming request
-   * @param {string} method - HTTP method
-   * @param {string} url - Request URL
-   * @returns {Object|null} - Matched route info or null
-   */
   match(method, url) {
-    // Parse URL and query parameters
-    const [pathname, search] = url.split("?");
-    const query = this._parseQuery(search);
+    const qIndex = url.indexOf("?");
+    const pathname = qIndex === -1 ? url : url.substring(0, qIndex);
+    const search = qIndex === -1 ? null : url.substring(qIndex + 1);
     
-    // Find matching route
-    for (const [routeKey, route] of this.routes) {
-      const [routeMethod, routePath] = routeKey.split(":");
-      
-      // Check method match
-      if (routeMethod !== "ANY" && routeMethod !== method) {
-        continue;
+    const cacheKey = method + ":" + pathname;
+    const cached = this.routeCache.get(cacheKey);
+    
+    if (cached !== undefined) {
+      const route = cached.route;
+      const params = route && !route.isStatic ? this._extractParams(route, pathname) : EMPTY_PARAMS;
+      return {
+        route: route,
+        params: params,
+        query: search ? this.jitQueryParser.parse(search) : EMPTY_QUERY,
+        handlers: cached.handlers
+      };
+    }
+
+    const applicableMiddlewares = [];
+    for (let i = 0; i < this.globalMiddlewares.length; i++) applicableMiddlewares.push(this.globalMiddlewares[i]);
+    
+    for (let i = 0; i < this.prefixMiddlewares.length; i++) {
+      const mw = this.prefixMiddlewares[i];
+      const mwPath = mw.path;
+      const mwPathSlash = mwPath.endsWith('/') ? mwPath : mwPath + '/';
+      if (pathname === mwPath || pathname.startsWith(mwPathSlash)) {
+        for (let j = 0; j < mw.handlers.length; j++) applicableMiddlewares.push(mw.handlers[j]);
       }
-      
-      // Check path match
-      const match = pathname.match(route.regex);
-      if (match) {
-        const params = {};
+    }
+
+    let matchedRoute = null;
+    matchedRoute = this.staticRoutes.get(method + ":" + pathname) || this.staticRoutes.get("ANY:" + pathname);
+
+    // [FIX] 修复了高并发下 _lastMatch 挂载在共享 route 对象上导致的“串参”竞态条件问题
+    let dynamicMatch = null; 
+    if (!matchedRoute) {
+      for (let i = 0; i < this.dynamicRoutes.length; i++) {
+        const route = this.dynamicRoutes[i];
+        if (route.method !== null && route.method !== method) continue;
         
-        // Extract named parameters
-        if (match.groups) {
-          Object.assign(params, match.groups);
+        const match = route.regex.exec(pathname);
+        if (match) {
+          matchedRoute = route;
+          dynamicMatch = match; // 使用局部变量保存匹配结果
+          break;
         }
-        
-        // Extract positional parameters
-        route.paramNames.forEach((name, index) => {
-          if (!params[name] && match[index + 1]) {
-            params[name] = match[index + 1];
-          }
-        });
-        
-        return {
-          route,
-          params,
-          query,
-          handlers: [...this.middlewares, ...route.handlers]
-        };
       }
     }
+
+    if (matchedRoute) {
+      const finalHandlers = applicableMiddlewares.concat(matchedRoute.handlers);
+      if (this.routeCache.size >= this.cacheMaxSize) this.routeCache.clear();
+      this.routeCache.set(cacheKey, { route: matchedRoute, handlers: finalHandlers });
+
+      const params = matchedRoute.isStatic ? EMPTY_PARAMS : this._extractParams(matchedRoute, pathname, dynamicMatch);
+      return {
+        route: matchedRoute,
+        params: params,
+        query: search ? this.jitQueryParser.parse(search) : EMPTY_QUERY,
+        handlers: finalHandlers
+      };
+    }
+    
+    if (applicableMiddlewares.length > 0) {
+      if (this.routeCache.size >= this.cacheMaxSize) this.routeCache.clear();
+      this.routeCache.set(cacheKey, { route: null, handlers: applicableMiddlewares });
+      return {
+        route: null,
+        params: EMPTY_PARAMS,
+        query: search ? this.jitQueryParser.parse(search) : EMPTY_QUERY,
+        handlers: applicableMiddlewares
+      };
+    }
     
     return null;
   }
 
-  /**
-   * Parse query string parameters
-   * @private
-   */
-  _parseQuery(search) {
-    const query = {};
-    if (!search) return query;
+  _extractParams(route, pathname, existingMatch) {
+    const match = existingMatch || route.regex.exec(pathname);
+    if (!match) return EMPTY_PARAMS;
     
-    const pairs = search.split("&");
-    for (const pair of pairs) {
-      const [key, value] = pair.split("=");
-      if (key) {
-        const decodedKey = decodeURIComponent(key);
-        const decodedValue = value ? decodeURIComponent(value) : "";
-        
-        // Support array parameters: key[]=value1&key[]=value2
-        if (decodedKey.endsWith("[]")) {
-          const arrayKey = decodedKey.slice(0, -2);
-          if (!query[arrayKey]) {
-            query[arrayKey] = [];
-          }
-          query[arrayKey].push(decodedValue);
-        } else {
-          query[decodedKey] = decodedValue;
-        }
-      }
+    const params = {};
+    const names = route.paramNames;
+    for (let i = 0; i < names.length; i++) {
+      params[names[i]] = match[i + 1];
     }
-    
-    return query;
+    return params;
   }
 
-  /**
-   * Generate router middleware for AetherPipeline
-   */
   middleware() {
     return async (context, next) => {
       const match = this.match(context.method, context.url);
       
       if (match) {
-        // Set route parameters and query parameters
         context.params = match.params;
-        context.setState("query", match.query); 
         context.route = match.route;
         
-        // Execute route handler chain
-        await this._executeHandlers(context, match.handlers);
+        if (typeof context.setState === "function") {
+          context.setState("query", match.query);
+        } else {
+          try { context.query = match.query; } catch (e) { /* Ignore */ }
+        }
+        
+        if (match.handlers && match.handlers.length > 0) {
+          const executor = this.jitExecutor.getExecutor(match.handlers);
+          await executor.call(match.handlers, context);
+        } else if (typeof next === "function") {
+          await next();
+        }
+        
+        if (!context.isTerminated() && !match.route && typeof next === "function") {
+          await next();
+        }
       } else if (typeof next === "function") {
-        // No matching route, continue to next middleware
         await next();
       } else {
-        // Return 404
-        context.setStatus(404).json({
-          error: "Not Found",
-          message: `Route ${context.method} ${context.url} not found`,
-          timestamp: new Date().toISOString()
-        });
+        context.setStatus(404).json({ error: "Not Found" });
       }
     };
   }
 
-  /**
-   * Execute handler chain
-   * @private
-   */
-  async _executeHandlers(context, handlers) {
-    let index = 0;
-    
-    const executeNext = async () => {
-      if (index >= handlers.length || context.isTerminated()) {
-        return;
-      }
-      
-      const handler = handlers[index++];
-      await handler(context, executeNext);
-    };
-    
-    await executeNext();
-  }
-
-  /**
-   * Get all registered routes (for debugging)
-   */
   getRoutes() {
     const routes = [];
-    this.routes.forEach((route, key) => {
-      const [method, path] = key.split(":");
-      routes.push({
-        method: method === "ANY" ? "ALL" : method,
-        path,
-        handlers: route.handlers.length
-      });
-    });
+    this.staticRoutes.forEach(r => routes.push({ method: r.method || "ALL", path: r.path, type: 'static' }));
+    for (let i = 0; i < this.dynamicRoutes.length; i++) {
+      const r = this.dynamicRoutes[i];
+      routes.push({ method: r.method || "ALL", path: r.path, type: 'dynamic' });
+    }
     return routes;
   }
 
-  /**
-   * Clear all routes and middlewares
-   */
   clear() {
-    this.routes.clear();
-    this.groups.clear();
-    this.middlewares = [];
+    this.staticRoutes.clear();
+    this.dynamicRoutes.length = 0;
+    this.globalMiddlewares.length = 0;
+    this.prefixMiddlewares.length = 0;
+    this.routeCache.clear();
     return this;
   }
 }