Returns the service description of the class.
It describes the class methods and its parameters including their types

@return array Associative list of class/method names, their parameters and types
176522
public function getServiceDescription()
	{
		$list = parent::getServiceDescription();

		$list['Coupon_Code.uploadFile'] = array(
			"parameters" => array(
				array( "type" => "string","name" => "site","optional" => false ),
				array( "type" => "string","name" => "couponid","optional" => false ),
			),
			"returns" => "array",
		);

		$list['Coupon_Code.importFile'] = array(
			"parameters" => array(
				array( "type" => "string","name" => "site","optional" => false ),
				array( "type" => "string","name" => "couponid","optional" => false ),
				array( "type" => "array","name" => "items","optional" => false ),
			),
			"returns" => "array",
		);

		return $list;
	}
42279
public function getServices()
    {
        $this->container = parent::getServices();
        $this->container['db'] = function ($c) {
            $db = new Db();
            $db->setCredentials($this->getDbConfig());
            $type = 'mysqli';
            if(class_exists('Pdo')) {
                $type = 'pdo';
            }
            
            $db->setAccessType($type);
            return $db;
        };
        
        $this->container['encrypt'] = function ($c) {
            $encrypt = new Encrypt();
            $new_key = $c['platform']->getEncryptionKey();
            $encrypt->setKey($new_key);
            return $encrypt;
        };
        
        $this->container['lang'] = function ($c) {
            $lang = new Language();
            if (is_array($this->getLangPath())) {
                foreach ($this->getLangPath() as $path) {
                    $lang->init($path);
                }
            } elseif ($this->getLangPath() != '') {
                $lang->init($this->getLangPath());
            }
            return $lang;
        };
        
        $this->container['validate'] = function ($c) {
            $validate = new Validate();
            $validate->setRegex($this->container['regex']);
            return $validate;
        };
        
        $this->container['files'] = function ($c) {
            $file = new Files();
            return $file;
        };
        
        $this->container['errors'] = function ($c) {
            $errors = new Errors();
            $errors->setValidation($c['validate']);
            return $errors;
        };
        
        $this->container['license'] = function ($c) {
            $license = new License();
            return $license;
        };
        
        $this->container['email'] = function ($c) {
            
            $email = new Email();
            $email->setView($c['view']);
            $email->setLang($c['lang']);
            return $email;
        };
        
        $this->container['view'] = function ($c) {
            $view = new View();
            $helpers = array(
                'file_size' => function ($text) {
                    return $this->container['view_helpers']->m62FileSize($text, false);
                },
                'lang' => function ($text) {
                    return $this->container['view_helpers']->m62Lang($text);
                },
                'date_time' => function ($text, $html = true) {
                    return $this->container['view_helpers']->m62DateTime($text, false);
                },
                'relative_time' => function ($date) {
                    return $this->container['view_helpers']->m62RelativeDateTime($date);
                },
                'encode' => function ($text) {
                    return $this->container['view_helpers']->m62Encode($text);
                },
                'decode' => function ($text) {
                    return $this->container['view_helpers']->m62Decode($text);
                }
            );
            
            $view->addHelper('m62', $helpers);
            return $view;
        };
        
        $this->container['regex'] = function ($c) {
            $regex = new Regex();
            return $regex;
        };
        
        $this->container['shell'] = function ($c) {
            $shell = new Shell();
            return $shell;
        };
        
        $this->container['console'] = function ($c) {
            $console = new Console();
            $console->setLang($c['lang']);
            return $console;
        };
        
        return $this->container;
    }
448824
private function getClassPublicMethods(): array
    {
        return \array_filter(\array_map(
            function (\ReflectionMethod $method): string {
                return !$method->isStatic() ? $method->getName() : '';
            },
            (new \ReflectionObject($this))->getMethods(\ReflectionMethod::IS_PUBLIC)
        ));
    }
333340
public function describeMany(array $services)
    {
        $descriptions = [];
        foreach ($services as $serviceId) {
            $descriptions[] = $this->describe($serviceId);
        }
        
        return $descriptions;
    }
555826
public function getServiceConfig()
    {
        return array(
            'initializers' => array(
                function ($instance, $sm) {
                    if ($instance instanceof \DlcBase\Module\ModuleNamespaceAwareInterface) {
                        $class           = get_class($instance);
                        $moduleNamespace = substr($class, 0, strpos($class, '\\'));
                        $instance->setModuleNamespace($moduleNamespace);
                    }
                }
            ),
        );
    }
109013
public function getServiceDescription()
    {
        if (null === $this->serviceDescription) {
            $serviceDescription = static::loadServiceDescription();
            $serviceDescription['ravelry.access_key'] = $this->authentication->getAccessKey();

            // we'll preset the upload_image parameter with our access_key
            $serviceDescription['operations']['upload_image']['parameters']['access_key']['default'] = $serviceDescription['ravelry.access_key'];

            $this->serviceDescription = new Description($serviceDescription);
        }

        return $this->serviceDescription;
    }
830510
public static function info()
    {
        $oReflectionClass = new \ReflectionClass(get_called_class());
        static::parse($oReflectionClass);

        $aOut = [];
        foreach ($oReflectionClass->getConstants() as $sConstant => $sValue) {
            $aOut[$sConstant] = (object) [
                'constant'    => get_called_class() . '::' . $sConstant,
                'namespace'   => static::getEventNamespace(),
                'value'       => $sValue,
                'description' => ArrayHelper::getFromArray($sConstant, static::$aDescriptions),
                'arguments'   => ArrayHelper::getFromArray($sConstant, static::$aArguments),
            ];
        }

        return $aOut;
    }
462726
public function termsOfServiceFormAction()
    {
        $form = $this->formFactory->create(
            new AdminForm\TermsOfServiceType(
                $this->configHandler->getParameter('terms_of_service'),
                $this->configHandler->getLockedParamaters()
            ),
            $this->termsOfService->getTermsOfService(false)
        );

        return array('form' => $form->createView());
    }
1255166
private function serviceDescription($object) {
        $class_name = get_class($object);
        $methods = get_class_methods($class_name);
        $service = ["sdversion" => "1.0",
                    "name" => "DemoService",
                    "address" => $this->currentURL(),
                    "id" => "urn:md5:" . md5($this->currentURL())];
        $static = get_class_vars($class_name);
        foreach ($methods as $method_name) {
            $proc = array("name" => $method_name);
            $method = new \ReflectionMethod($class_name, $method_name);
            $params = array();
            foreach ($method->getParameters() as $param) {
                $params[] = $param->name;
            }
            $proc['params'] = $params;
            $help_str_name = $method_name . "_documentation";
            if (array_key_exists($help_str_name, $static)) {
                $proc['help'] = $static[$help_str_name];
            }
            $service['procs'][] = $proc;
        }
        return $service;
    }
675565
public function getAllMethods() {
    $methods = array();
    foreach ($this->methodsOrder as $methodName) {
      $method = $this->methods[$methodName];
      $methods[$method->getName()] = $method;
    }
    return $methods;
  }
881960
public function getListFunctions() {
		if($this->listFunctions) return $this->listFunctions;

		$list = array ();
		foreach(ClassInfo::implementorsOf('SS_List') as $class) {
			$r = new ReflectionClass($class);			
			$methods = $r->getMethods();
			if($methods) {
				foreach($methods as $m) {
					$name = $m->getName();					
					if(preg_match("/[A-Z]/",$name[0])) {
						$list[] = strtolower($name);
					}											
				}
			}
		}

		return $this->listFunctions = $list;
	}
942504
public function describe() : array
    {
        $info = [
            'path' => $this->path,
            'maxDepth' => $this->maxDepth,
            'skipSymLinks' => $this->skipSymLinks,
            'dirs' => $this->dirs,
            'itemValue' => $this->itemValue,
            'traverseHidden' => $this->traverseHidden,
            'skipUnreadable' => $this->skipUnreadable,
            'requireUnique' => $this->requireUnique,
            // Count actual criteria.
            'criteriaCount' => (int) !$this->includeHidden,
            // First actual criteria.
            'includeHidden' => $this->includeHidden,
        ];
        $possible_empties = [
            'includeNames',
            'excludeNames',
            'includeExtensions',
            'excludeExtensions',
            'includeParents',
            'excludeParents',
            'customFilter',
        ];
        foreach ($possible_empties as $key) {
            if ($this->{$key}) {
                ++$info['criteriaCount'];
                $info[$key] = $this->{$key};
            }
        }
        return $info;
    }
693070
public function definedClasses() {
        $loops = $this->getLoops();

        $cache = $loops->getService("cache");

        $key = "Loops-Application-definedClasses";

        if($cache->contains($key)) {
            return $cache->fetch($key);
        }

        $require = function($dir) use (&$require, &$classes) {
            foreach(scandir($dir) as $file) {
                if(substr($file, 0, 1) == '.') {
                    continue;
                }

                $filename = "$dir/$file";

                if(is_dir($filename)) {
                    $require($filename);
                }
                else {
                    require_once($filename);
                }
            }
        };

        $dirs = $this->include_dir;

        array_walk($dirs, $require);

        $classes = array_values(array_filter(get_declared_classes(), function($classname) use ($dirs, $cache) {
            $reflection = new ReflectionClass($classname);
            $filename = $reflection->getFileName();

            if(!$filename) {
                return FALSE;
            }

            if($this->enable_cached_autoload) {
                $key = "Loops-Application-autoload-$classname";
                $cache->save($key, $filename);
            }

            foreach($dirs as $dir) {
                if(substr($filename, 0, strlen($dir)) == $dir) {
                    return TRUE;
                }
            }

            return FALSE;
        }));

        $cache->save($key, $classes);

        return $classes;
    }
68504
public function getClassAndMethodNamesForCalling(): array
    {
        $domain = $this->consoleInput->getDomainName();
        $action = $this->consoleInput->getActionName();

        $className = self::getFQDNClass($domain);

        return [$className, $domain, $action];
    }
901003
public function toArray() {
        $params = array();
        foreach ($this->getParams() as $param) {
            $params[$param->getName()] = $param->toArray();
        }
        $m = array(
            //'description',
            //'transport' => null,
            'parameters' => $params,
            //'returns' => null
        );
        if ($this->use_canonical) {
            $m['target'] = $this->smd->getTarget(). '/' . $this->service->getDottedClassname() . '.' . $this->getName();
        }
        return $m;
    }
1156104
public function getServiceIds()
    {
        return array_unique(array_merge(['service_container'], array_keys($this->fileMap), array_keys($this->methodMap), array_keys($this->services)));
    }
837187
public function describe()
    {
        $columns = [];
        foreach ($this->columns as $id => $params) {
            $columns[$id] = [
                'title'     => $params['title'],
                'type'      => $params['type'],
                'filters'   => $params['filters'],
                'sortable'  => $params['sortable'],
                'visible'   => $params['visible'],
            ];
        }

        return [
            'columns' => $columns,
        ];
    }