Get the SuggestionsInterface.

@return The SuggestionsInterface
514594
@Override
    public SuggestionsInterface getSuggestionsInterface() {
        if (suggestionsInterface == null) {
            suggestionsInterface = new SuggestionsInterface(apiKey, sharedSecret, transport);
        }
        return suggestionsInterface;
    }
1133350
public function getAdminAction(): ResponseInterface
    {
        $this->layout = 'layouts/administration';

        return $this->viewResponse('modules/custom-css-js/edit', [
            'title' => $this->title(),
            'head'  => $this->getPreference('head'),
            'body'  => $this->getPreference('body'),
        ]);
    }
67363
ITypeDecl getDefaultInterface( ICoClassDecl t ) {
        final int count = t.countImplementedInterfaces();
        // look for the default interface first.
        for( int i=0; i<count; i++ ) {
            IImplementedInterfaceDecl impl = t.getImplementedInterface(i);
            if(impl.isSource())
                continue;
            if(impl.isDefault()){
              IInterfaceDecl c = getCustom(impl);
              if(c!=null)
                return c;
              IDispInterfaceDecl d = impl.getType().queryInterface(IDispInterfaceDecl.class);
              if(d != null){
                return d;
              }
            }
        }

        // if none is found, look for any non-source interface
        Set<IInterfaceDecl> types = new HashSet<IInterfaceDecl>();
        for( int i=0; i<count; i++ ) {
            IImplementedInterfaceDecl impl = t.getImplementedInterface(i);
            if(impl.isSource())
                continue;
            IInterfaceDecl c = getCustom(impl);
            if(c !=null)
                types.add(c);
        }

        if(types.isEmpty())
            return null;

        // if T1 and T2 are in the set and T1 derives from T2, eliminate T2
        // (since returning T1 is better)
        Set<IInterfaceDecl> bases = new HashSet<IInterfaceDecl>();
        for (IInterfaceDecl ii : types) {
            for( int i=0; i<ii.countBaseInterfaces(); i++)
                bases.add(ii.getBaseInterface(i).queryInterface(IInterfaceDecl.class));
        }
        types.removeAll(bases);

        return types.iterator().next();
    }
1155043
public Interactions getInteractions() {
		try {
			if (!isNull(Interactions.KEY_NAME)) {
				Object obj = get(Interactions.KEY_NAME);
				if (obj instanceof JSONArray) {
					Interactions interactions = new Interactions();
					JSONArray interactionsJSONArray = (JSONArray) obj;
					for (int i = 0; i < interactionsJSONArray.length(); i++) {
						Interaction interaction = Interaction.Factory.parseInteraction(interactionsJSONArray.getString(i));
						if (interaction != null) {
							interactions.put(interaction.getId(), interaction);
						} else {
							// This is an unknown Interaction type. Probably for a future SDK version.
						}
					}
					return interactions;
				}
			}
		} catch (JSONException e) {
			ApptentiveLog.w(INTERACTIONS, e, "Unable to load Interactions from InteractionManifest.");
			logException(e);
		}
		return null;
	}
850947
public final CommandInterceptor getNext() {
      List<AsyncInterceptor> interceptors = interceptorChain.wired().getInterceptors();
      int myIndex = interceptors.indexOf(this);
      if (myIndex < interceptors.size() - 1) {
         AsyncInterceptor asyncInterceptor = interceptors.get(myIndex + 1);
         if (asyncInterceptor instanceof CommandInterceptor)
            return (CommandInterceptor) asyncInterceptor;
      }
      return null;
   }
1268931
public java.util.List<SuggestionMatch> getSuggestions() {
        if (suggestions == null) {
            suggestions = new com.amazonaws.internal.SdkInternalList<SuggestionMatch>();
        }
        return suggestions;
    }
237782
public JClass []getInterfaces()
  {
    lazyLoad();
    
    JClass []interfaces = new JClass[_interfaces.size()];

    for (int i = 0; i < _interfaces.size(); i++) {
      String name = _interfaces.get(i);
      name = name.replace('/', '.');
      
      interfaces[i] = getClassLoader().forName(name);
    }
    
    return interfaces;
  }
473814
public function getInterceptedRequest()
    {
        if ($this->initialized === false) {
            $this->initialize();
        }

        $sessionDataContainer = $this->objectManager->get(SessionDataContainer::class);
        return $sessionDataContainer->getInterceptedRequest();
    }
577010
public String getInterfaceClassName()
    {
    	Class<?> interfaceClass = getInterfaceClass();
    	if (interfaceClass != null)
    		return interfaceClass.getName();
		String interfaceClassName = this.getProperty(BundleConstants.INTERFACE);
		if (interfaceClassName == null)
		{
			if (service != null)
				interfaceClassName = service.getClass().getName();	// Default - register under class name
			else
				interfaceClassName = this.getClass().getName();	// Default - register under class name
		}
		return interfaceClassName;
    }
1315857
public JClass []getInterfaces()
  {
    Class []cl = _class.getInterfaces();

    JClass []clList = new JClass[cl.length];

    for (int i = 0; i < cl.length; i++)
      clList[i] = _loader.forName(cl[i].getName());

    return clList;
  }
1213821
public static String[] discoverInterfaces(byte[] classbytes) {
		ClassReader cr = new ClassReader(classbytes);
		InterfaceCollectingClassVisitor f = new InterfaceCollectingClassVisitor();
		cr.accept(f, 0);
		return f.interfaces;
	}
429664
public AptControlInterface getControlInterface()
    {
        if (_controlIntf == null)
        {
            _controlIntf = initControlInterface();
            if (_controlIntf != null)
                initTypeParameterBindings();
        }
        return _controlIntf;
    }
265489
public final double[] getDpiSuggestions() {
        if (this.dpiSuggestions == null) {
            List<Double> list = new ArrayList<>();
            for (double suggestion: DEFAULT_DPI_VALUES) {
                if (suggestion <= this.maxDpi) {
                    list.add(suggestion);
                }
            }
            double[] suggestions = new double[list.size()];
            for (int i = 0; i < suggestions.length; i++) {
                suggestions[i] = list.get(i);
            }
            return suggestions;
        }
        return this.dpiSuggestions;
    }
792413
static Class getMostDerivedInterface(Class controlIntf)
    {
        while (controlIntf.isAnnotationPresent(ControlExtension.class))
        {
            Class [] intfs = controlIntf.getInterfaces();
            boolean found = false;
            for (int i = 0; i < intfs.length; i++)
            {
                if (intfs[i].isAnnotationPresent(ControlExtension.class) ||
                    intfs[i].isAnnotationPresent(ControlInterface.class))
                {
                    controlIntf = intfs[i];
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                throw new ControlException("Can't find base control interface for " + controlIntf);
            }
        }
        return controlIntf;
    }
761780
static List<NetworkInterface> getInterfaces() throws SocketException {
        List<NetworkInterface> all = new ArrayList<NetworkInterface>();
        addAllInterfaces(all, Collections.list(NetworkInterface.getNetworkInterfaces()));
        return all;
    }
285678
protected function detectType()
    {
        if (property_exists($this, 'allow')) {
            return $this->allow;
        }

        $interfaces = (new ReflectionClass($this))->getInterfaceNames();

        if ($interfaces) {
            return $interfaces[0];
        }

        return get_class($this);
    }
118711
protected function DefineInterface()
    {
        parent::DefineInterface();
        $this->methodCallAllowed[] = 'WriteReview';
        $this->methodCallAllowed[] = 'RateReview';
        $this->methodCallAllowed[] = 'ReportReview';
        $this->methodCallAllowed[] = 'DeleteReview';
        $this->methodCallAllowed[] = 'UnlockReview';
        $this->methodCallAllowed[] = 'EditReview';
        $this->methodCallAllowed[] = 'ChangeReviewReportNotificationState';
        // pkgComment functions
        $this->methodCallAllowed[] = 'WriteComment';
        $this->methodCallAllowed[] = 'ReportComment';
        $this->methodCallAllowed[] = 'RespondToComment';
        $this->methodCallAllowed[] = 'EditComment';
        $this->methodCallAllowed[] = 'DeleteComment';
    }