text:
<?php

namespace MMiic\GeTui\Igetui\Reqs;

use MMiic\GeTui\Protobuf\PBMessage;

class PushListResult extends PBMessage
{
    var $wired_type = PBMessage::WIRED_LENGTH_DELIMITED;
    public function __construct($reader=null)
    {
        parent::__construct($reader);
        $this->fields["1"] = "PushResult";
        $this->values["1"] = array();
    }
    function results($offset)
    {
        return $this->_get_arr_value("1", $offset);
    }
    function add_results()
    {
        return $this->_add_arr_value("1");
    }
    function set_results($index, $value)
    {
        $this->_set_arr_value("1", $index, $value);
    }
    function remove_last_results()
    {
        $this->_remove_last_arr_value("1");
    }
    function results_size()
    {
        return $this->_get_arr_size("1");
    }
}

?>


text:
#include <stdint.h>

#include "gtest/gtest.h"
#include "utils/shared_ptr.h"
#include "smart_objects/smart_object.h"
#include "application_manager/smart_object_keys.h"
#include "application_manager/commands/commands_test.h"
#include "application_manager/commands/command.h"
#include "application_manager/mock_event_dispatcher.h"
#include "hmi/response_from_hmi.h"

namespace test {
namespace components {
namespace commands_test {
namespace hmi_commands_test {
namespace response_from_hmi {

using ::testing::_;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::DoAll;

using ::utils::SharedPtr;
using ::test::components::event_engine_test::MockEventDispatcher;

namespace am = ::application_manager;

using am::commands::ResponseFromHMI;

typedef SharedPtr<ResponseFromHMI> ResponseFromHMIPtr;

class ResponseFromHMITest : public CommandsTest<CommandsTestMocks::kIsNice> {};

TEST_F(ResponseFromHMITest, BasicMethodsOverloads_SUCCESS) {
  ResponseFromHMIPtr command(CreateCommand<ResponseFromHMI>());

  // Current implementation always return `true`
  EXPECT_TRUE(command->Init());
  EXPECT_NO_THROW(command->Run());
  EXPECT_TRUE(command->CleanUp());
}

TEST_F(ResponseFromHMITest, SendResponseToMobile_SUCCESS) {
  ResponseFromHMIPtr command(CreateCommand<ResponseFromHMI>());

  MessageSharedPtr msg(CreateMessage(smart_objects::SmartType_Map));

  EXPECT_CALL(app_mngr_, ManageMobileCommand(msg, _));

  command->SendResponseToMobile(msg, app_mngr_);

  const application_manager::MessageType received_message_tipe =
      static_cast<application_manager::MessageType>(
          (*msg)[am::strings::params][am::strings::message_type].asInt());

  EXPECT_EQ(application_manager::MessageType::kResponse, received_message_tipe);
}

TEST_F(ResponseFromHMITest, CreateHMIRequest_SUCCESS) {
  ResponseFromHMIPtr command(CreateCommand<ResponseFromHMI>());

  MessageSharedPtr result_msg;
  EXPECT_CALL(app_mngr_, ManageHMICommand(_))
      .WillOnce(DoAll(SaveArg<0>(&result_msg), Return(true)));

  const hmi_apis::FunctionID::eType posted_function_id =
      hmi_apis::FunctionID::INVALID_ENUM;
  MessageSharedPtr dummy_msg_params = CreateMessage();
  command->CreateHMIRequest(posted_function_id, *dummy_msg_params);

  ASSERT_TRUE(result_msg);

  const application_manager::MessageType received_message_tipe =
      static_cast<application_manager::MessageType>(
          (*result_msg)[am::strings::params][am::strings::message_type]
              .asInt());

  EXPECT_EQ(am::MessageType::kRequest, received_message_tipe);

  const hmi_apis::FunctionID::eType received_function_id =
      static_cast<hmi_apis::FunctionID::eType>(
          (*result_msg)[am::strings::params][am::strings::function_id].asInt());

  EXPECT_EQ(posted_function_id, received_function_id);
}

TEST_F(ResponseFromHMITest, CreateHMIRequest_CantManageCommand_Covering) {
  ResponseFromHMIPtr command(CreateCommand<ResponseFromHMI>());

  MessageSharedPtr result_msg;
  ON_CALL(app_mngr_, GetNextHMICorrelationID()).WillByDefault(Return(1u));
  EXPECT_CALL(app_mngr_, ManageHMICommand(_))
      .WillOnce(DoAll(SaveArg<0>(&result_msg), Return(false)));

  const hmi_apis::FunctionID::eType posted_function_id =
      hmi_apis::FunctionID::INVALID_ENUM;
  MessageSharedPtr dummy_msg_params = CreateMessage();
  command->CreateHMIRequest(posted_function_id, *dummy_msg_params);
}

}  // namespace response_from_hmi
}  // namespace hmi_commands_test
}  // namespace commands_test
}  // namespace components
}  // namespace test

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.salesforce.samples.reactnativetemplateapp"
	android:versionCode="1"
	android:versionName="1.0"
	android:installLocation="internalOnly">

	<application android:icon="@drawable/sf__icon"
	    android:label="@string/app_name"
		android:name=".ReactNativeTemplateApp"
		android:manageSpaceActivity="com.salesforce.androidsdk.ui.ManageSpaceActivity">

		<!-- Launcher screen -->
		<activity android:name=".MainActivity"
		    android:label="@string/app_name"
			android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
			<intent-filter>
				<action android:name="android.intent.action.MAIN" />
				<category android:name="android.intent.category.LAUNCHER" />
			</intent-filter>
		</activity>

        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />

	</application>

    <uses-sdk android:minSdkVersion="19"
        android:targetSdkVersion="23" />
</manifest>


text:
#include <stdio.h>
/*
 * TODO: The long time goal is for this file to die. Every .c
 * file should be a module that should have a corresponding .h
 * file that contains the public functions of that module.
 */

/* Prototypes for functions defined in NiKomSer.c */
BYTE OpenConsole(struct Window *window);
BYTE OpenSerial(struct IOExtSer *writereq,struct IOExtSer *readreq,struct IOExtSer *changereq);
BYTE OpenTimer(struct timerequest *treq);
void CloseConsole(void);
void CloseSerial(struct IOExtSer *writereq);
void CloseTimer(struct timerequest *treq);
void writesererr(int);
char gettekn(void);
char congettkn(void);
char sergettkn(void);
void eka(char tecken);
void coneka(char tecken);
void conreqtkn(void);
void serreqtkn(void);
void putstring(char *pekare,int size, long flags);
int puttekn(char *pekare,int size);
void modemcmd(char *pekare,int size);
void paus(ULONG tid);
void getnodeconfig(char *);
char convseventoeight(char foo);
char conveighttoseven(char foo);
void convstring(char *string);
void sendat(char *atstring);
void sendplus(void);
void freealiasmem(void);
void waitconnect(void);
void cleanup(int kod,char *text);
void main(int argc,char **argv);
int getfifoevent(struct MsgPort *fifoport,char *puthere);

/* Lite temporärt såhär.. Egentligen SerialIO.c.. */
int OpenIO(struct Window *);
void CloseIO(void);
void abortserial(void);
int tknwaiting(void);
int incantrader(void);
int sendtocon(char *pekare, int);
int checkcharbuffer(void);
int sendtosercon(char *conpek, char *serpek, int consize, int sersize);

int serputtekn(char *pekare,int size);
void sereka(char tecken);
int sendtoser(char *pekare, int);

/* ServerComm.c.. */
long sendservermess(short, long);
int initnode(int);
void shutdownnode(int);
void handleservermess(struct NiKMess *);

/* Prototypes for functions defined in NiKFuncs.c */
int countmote(int mote);
void var(int mot);
int visatext(int text);
void tiden(void);
int skapmot(void);
void listmot(char *);
int parse(char *skri);
int parsemot(char *skri);
void medlem(char *args);
void uttrad(char *args);
void sparatext(void);
void linkkom(void);
int initheader(int komm);
int countunread(int meet);
void initLowestPossibleUnreadTexts(void);
void connection(void);
void varmote(int mote);
int skriv(void);
void igen(void);

/* Prototypes for functions defined in NiKFuncs2.c */
int countmail(int user,int brevpek);
void varmail(void);
void visabrev(int brev,int anv);
int recisthere(char *str,int rec);
int updatenextletter(int user);
int parsenamn(char *skri);
int matchar(char *skrivet,char *facit);
char *hittaefter(char *strang);
void listmed(void);
void listratt(void);
void listnyheter(void);
void listflagg(void);
void slaav(void);
void slapa(void);
int ropa(void);
void writemeet(struct Mote * );
void addratt(void);
void subratt(void);

/* Prototypes for functions defined in NiKFuncs3.c */
void endast(void);
int personlig(void);
void radtext(void);
int radmot(void);
int andmot(void);
void radbrev(void);
void vilka(void);
int skickabrev(void);
void initpersheader(void);
void visainfo(void);
void NiKForbid(void);
void NiKPermit(void);
int readtexthead(int nummer,struct Header *head);
int writetexthead(int nummer,struct Header *head);
int readletterheader(BPTR fh,struct ReadLetter *rl);
int getnextletter(int user);
int getfirstletter(int user);
int readuser(int nummer,struct User *user);
int writeuser(int nummer,struct User *user);
void rensatexter(void);
void gamlatexter(void);
void gamlabrev(void);
void getconfig(void);
void writeinfo(void);
void displaysay(void);
int sag(void);
void writesenaste(void);
void listasenaste(void);
int dumpatext(void);
void listaarende(void);
void tellallnodes(char *str);
int skrivlapp(void);
void radlapp(void);
int userexists(int nummer);

/* Prototypes for functions defined in NiKFuncs4.c */
int movetext(void);
char *getusername(int nummer);
int namematch(char *pat,char *fac);
int skapagrupp(void);
int writegrupp(int nummer,struct UserGroup *pek);
void listagrupper(void);
int adderagruppmedlem(void);
int subtraheragruppmedlem(void);
int parsegrupp(char *skri);
int andragrupp(void);
void raderagrupp(void);
void initgrupp(void);
char *getgruppname(int nummer);
int editgrupp(char *bitmap);
void motesstatus(void);
void hoppaarende(void);
int arearatt(int area, int usrnr, struct User *usr);
int gruppmed(struct UserGroup *grupp,char status,long grupper);
void listgruppmed(void);
struct Alias *parsealias(char *skri);
void listalias(void);
void remalias(void);
void defalias(void);
void alias(void);
int speciallogin(char bokstav);
int readtextlines(long pos,int rader,int nummer);
void freeeditlist(void);
void listabrev(void);
void rensabrev(void);
int rek_flyttagren(int rot,int ack,int tomeet);
void flyttagren(void);
int execfifo(char *command,int cooked);

/* Prototypes for functions defined in NiKFuncs5.c */
struct Mote *getmotpek(int);
char *getmotnamn(int);
struct Kommando *getkmdpek(int);
int bytnodtyp(void);
void dellostsay(void);
void bytteckenset(void);
void SaveCurrentUser(int, int);   /* Kommandot SPARA */

/* Prototypes for functions defined in NiKEditor.c */
int edittext(char *filnamn);

/* Prototypes for functions defined in NiKFiles.c */
int parsearea(char *skri);
void listarea(void);
int parsenyckel(char *skri);
void listnyckel(void);
void listfiler(void);
void bytarea(void);
void filinfo(void);
void radarea(void);
int andraarea(void);
int skapafil(void);
void radfil(void);
int andrafil(void);
int lagrafil(void);
int flyttafil(void);
int incsearch(char *string,char *patt);
int sokfil(void);
struct Fil *parsefil(char *skri,int area);
struct Fil *parsefilallareas(char *);
void raisefiledl(struct Fil *filpek);
void filstatus(void);
void typefil(void);
void nyafiler(void);
int editkey(char *bitmap);
int choosedir(int area,char *nycklar,int size);
void validerafil(void);
struct Fil *filexists(char *skri,int area);

/* Prototypes for functions defined in NiKTransfer.c */
long __regargs __saveds nik_fopen(char *filename,char *accessmode);
long __regargs __saveds nik_fclose(LONG *fh);
long __regargs __saveds nik_fread(char *databuffer,long size,long count,LONG *fh);
long __regargs __saveds nik_fwrite(char *databuffer,long size,long count,LONG *fh);
long __regargs __saveds nik_fseek(LONG *fh,long offset,long origin);
long __regargs __saveds nik_sread(char *databuffer,long size,long timeout);
long __regargs __saveds nik_swrite(char *databuffer,long size);
long __regargs __saveds nik_update(struct XPR_UPDATE *update);
long __regargs __saveds nik_sflush(void);
long __regargs __saveds nik_chkabort(void);
long __regargs __saveds nik_gets(char *prompt,char *buffer);
long __regargs __saveds nik_finfo(char *filename,long typeinfo);
long __regargs __saveds nik_ffirst(char *buffer,char *pattern);
long __regargs __saveds nik_fnext(long oldstate,char *buffer,char *pattern);
void xpr_setup(struct XPR_IO *sio);
int download(void);
int valnamn(char *namn,int area,char *textbuf);
int upload(void);
int recbinfile(char *dir);
int sendbinfile(void);

/* Prototypes for functions defined in NiKOffline.c */
int grabtext(int text,FILE *fpgrab);
int grabfidotext(int, struct Mote *,FILE *);
int grabbrev(int text,FILE *fpgrab);
int grabkom(FILE *fp);
void grab(void);

/* Prototypes for functions defined in NiKRexx.c */
void sendrexx(int komnr);
void sendautorexx(int komnr);

/* Prototypes for functions defined in NiKUUCico.c */
void douucico(void);

/* Prototypes for functions defined in Brev.c */
int getzone(char *);
int getnode(char *);
int getnet(char *);
int getpoint(char *);
int brev_kommentera(void);
void brev_lasa(int tnr);
int countmail(int user,int brevpek);
void varmail(void);
void visabrev(int brev,int anv);
void visafidobrev(struct ReadLetter *,BPTR,int,int);
int initbrevheader(int tillpers);
int fido_brev(char *,char *,struct Mote *);
void sparabrev(void);
void sprattgok(char *);
void savefidocopy(struct FidoText *,int);

/* Prototypes for functions defined in OrgMeet.c */
int org_skriv(void);
void org_kommentera(void);
void org_lasa(int, char);
int checkmote(int);
void varmote(int);
int org_visatext(int, char);
void org_sparatext(void);
void org_linkkom(void);
int org_initheader(int);
void org_endast(int, int);

/* Prototypes for functions defined in FidoMeet.c */
void fido_lasa(int tnr,struct Mote *motpek);
int countfidomote(struct Mote *motpek);
void fido_visatext(int text,struct Mote *motpek);
void fido_endast(struct Mote *,int);
void makefidodate(char *);
void makefidousername(char *,int);
struct FidoDomain *getfidodomain(int,int);
int fido_skriv(int,int);
void fidolistaarende(struct Mote *,int);

/* Prototypes for functions defined in noansi.c */
void noansi(char *);


text:
package com.amazonaws.services.ec2.model;

import java.io.Serializable;

import com.amazonaws.AmazonWebServiceRequest;
import com.amazonaws.Request;
import com.amazonaws.services.ec2.model.transform.DescribeVpcEndpointsRequestMarshaller;

/**
 * Container for the parameters to the {@link com.amazonaws.services.ec2.AmazonEC2#describeVpcEndpoints(DescribeVpcEndpointsRequest) DescribeVpcEndpoints operation}.
 *

 * Describes one or more of your VPC endpoints.
 *

 *
 * @see com.amazonaws.services.ec2.AmazonEC2#describeVpcEndpoints(DescribeVpcEndpointsRequest)
 */
public class DescribeVpcEndpointsRequest extends AmazonWebServiceRequest implements Serializable, Cloneable, DryRunSupportedRequest<DescribeVpcEndpointsRequest> {

    /**
     * One or more endpoint IDs.
     */
    private com.amazonaws.internal.ListWithAutoConstructFlag<String> vpcEndpointIds;

    /**
     * One or more filters.

service-name: The name
     * of the AWS service.

vpc-id: The ID of the
     * VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     * (pending | available | deleting
     * | deleted)

     */
    private com.amazonaws.internal.ListWithAutoConstructFlag<Filter> filters;

    /**
     * The maximum number of items to return for this request. The request
     * returns a token that you can specify in a subsequent call to get the
     * next set of results.
Constraint: If the value is greater than 1000,
     * we return only 1000 items.
     */
    private Integer maxResults;

    /**
     * The token for the next set of items to return. (You received this
     * token from a prior call.)
     */
    private String nextToken;

    /**
     * One or more endpoint IDs.
     *
     * @return One or more endpoint IDs.
     */
    public java.util.List<String> getVpcEndpointIds() {
        if (vpcEndpointIds == null) {
              vpcEndpointIds = new com.amazonaws.internal.ListWithAutoConstructFlag<String>();
              vpcEndpointIds.setAutoConstruct(true);
        }
        return vpcEndpointIds;
    }

    /**
     * One or more endpoint IDs.
     *
     * @param vpcEndpointIds One or more endpoint IDs.
     */
    public void setVpcEndpointIds(java.util.Collection<String> vpcEndpointIds) {
        if (vpcEndpointIds == null) {
            this.vpcEndpointIds = null;
            return;
        }
        com.amazonaws.internal.ListWithAutoConstructFlag<String> vpcEndpointIdsCopy = new com.amazonaws.internal.ListWithAutoConstructFlag<String>(vpcEndpointIds.size());
        vpcEndpointIdsCopy.addAll(vpcEndpointIds);
        this.vpcEndpointIds = vpcEndpointIdsCopy;
    }

    /**
     * One or more endpoint IDs.
     *

     * NOTE: This method appends the values to the existing list (if
     * any). Use {@link #setVpcEndpointIds(java.util.Collection)} or {@link
     * #withVpcEndpointIds(java.util.Collection)} if you want to override the
     * existing values.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param vpcEndpointIds One or more endpoint IDs.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withVpcEndpointIds(String... vpcEndpointIds) {
        if (getVpcEndpointIds() == null) setVpcEndpointIds(new java.util.ArrayList<String>(vpcEndpointIds.length));
        for (String value : vpcEndpointIds) {
            getVpcEndpointIds().add(value);
        }
        return this;
    }

    /**
     * One or more endpoint IDs.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param vpcEndpointIds One or more endpoint IDs.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withVpcEndpointIds(java.util.Collection<String> vpcEndpointIds) {
        if (vpcEndpointIds == null) {
            this.vpcEndpointIds = null;
        } else {
            com.amazonaws.internal.ListWithAutoConstructFlag<String> vpcEndpointIdsCopy = new com.amazonaws.internal.ListWithAutoConstructFlag<String>(vpcEndpointIds.size());
            vpcEndpointIdsCopy.addAll(vpcEndpointIds);
            this.vpcEndpointIds = vpcEndpointIdsCopy;
        }

        return this;
    }

    /**
     * One or more filters.

service-name: The name
     * of the AWS service.

vpc-id: The ID of the
     * VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     * (pending | available | deleting
     * | deleted)

     *
     * @return One or more filters.

service-name: The name
     *         of the AWS service.

vpc-id: The ID of the
     *         VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     *         (pending | available | deleting
     *         | deleted)

     */
    public java.util.List<Filter> getFilters() {
        if (filters == null) {
              filters = new com.amazonaws.internal.ListWithAutoConstructFlag<Filter>();
              filters.setAutoConstruct(true);
        }
        return filters;
    }

    /**
     * One or more filters.

service-name: The name
     * of the AWS service.

vpc-id: The ID of the
     * VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     * (pending | available | deleting
     * | deleted)

     *
     * @param filters One or more filters.

service-name: The name
     *         of the AWS service.

vpc-id: The ID of the
     *         VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     *         (pending | available | deleting
     *         | deleted)

     */
    public void setFilters(java.util.Collection<Filter> filters) {
        if (filters == null) {
            this.filters = null;
            return;
        }
        com.amazonaws.internal.ListWithAutoConstructFlag<Filter> filtersCopy = new com.amazonaws.internal.ListWithAutoConstructFlag<Filter>(filters.size());
        filtersCopy.addAll(filters);
        this.filters = filtersCopy;
    }

    /**
     * One or more filters.

service-name: The name
     * of the AWS service.

vpc-id: The ID of the
     * VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     * (pending | available | deleting
     * | deleted)

     *

     * NOTE: This method appends the values to the existing list (if
     * any). Use {@link #setFilters(java.util.Collection)} or {@link
     * #withFilters(java.util.Collection)} if you want to override the
     * existing values.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param filters One or more filters.

service-name: The name
     *         of the AWS service.

vpc-id: The ID of the
     *         VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     *         (pending | available | deleting
     *         | deleted)

     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withFilters(Filter... filters) {
        if (getFilters() == null) setFilters(new java.util.ArrayList<Filter>(filters.length));
        for (Filter value : filters) {
            getFilters().add(value);
        }
        return this;
    }

    /**
     * One or more filters.

service-name: The name
     * of the AWS service.

vpc-id: The ID of the
     * VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     * (pending | available | deleting
     * | deleted)

     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param filters One or more filters.

service-name: The name
     *         of the AWS service.

vpc-id: The ID of the
     *         VPC in which the endpoint resides.

     *
vpc-endpoint-id: The ID of the endpoint.

     *
vpc-endpoint-state: The state of the endpoint.
     *         (pending | available | deleting
     *         | deleted)

     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withFilters(java.util.Collection<Filter> filters) {
        if (filters == null) {
            this.filters = null;
        } else {
            com.amazonaws.internal.ListWithAutoConstructFlag<Filter> filtersCopy = new com.amazonaws.internal.ListWithAutoConstructFlag<Filter>(filters.size());
            filtersCopy.addAll(filters);
            this.filters = filtersCopy;
        }

        return this;
    }

    /**
     * The maximum number of items to return for this request. The request
     * returns a token that you can specify in a subsequent call to get the
     * next set of results.
Constraint: If the value is greater than 1000,
     * we return only 1000 items.
     *
     * @return The maximum number of items to return for this request. The request
     *         returns a token that you can specify in a subsequent call to get the
     *         next set of results.
Constraint: If the value is greater than 1000,
     *         we return only 1000 items.
     */
    public Integer getMaxResults() {
        return maxResults;
    }

    /**
     * The maximum number of items to return for this request. The request
     * returns a token that you can specify in a subsequent call to get the
     * next set of results.
Constraint: If the value is greater than 1000,
     * we return only 1000 items.
     *
     * @param maxResults The maximum number of items to return for this request. The request
     *         returns a token that you can specify in a subsequent call to get the
     *         next set of results.
Constraint: If the value is greater than 1000,
     *         we return only 1000 items.
     */
    public void setMaxResults(Integer maxResults) {
        this.maxResults = maxResults;
    }

    /**
     * The maximum number of items to return for this request. The request
     * returns a token that you can specify in a subsequent call to get the
     * next set of results.
Constraint: If the value is greater than 1000,
     * we return only 1000 items.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param maxResults The maximum number of items to return for this request. The request
     *         returns a token that you can specify in a subsequent call to get the
     *         next set of results.
Constraint: If the value is greater than 1000,
     *         we return only 1000 items.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withMaxResults(Integer maxResults) {
        this.maxResults = maxResults;
        return this;
    }

    /**
     * The token for the next set of items to return. (You received this
     * token from a prior call.)
     *
     * @return The token for the next set of items to return. (You received this
     *         token from a prior call.)
     */
    public String getNextToken() {
        return nextToken;
    }

    /**
     * The token for the next set of items to return. (You received this
     * token from a prior call.)
     *
     * @param nextToken The token for the next set of items to return. (You received this
     *         token from a prior call.)
     */
    public void setNextToken(String nextToken) {
        this.nextToken = nextToken;
    }

    /**
     * The token for the next set of items to return. (You received this
     * token from a prior call.)
     *

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param nextToken The token for the next set of items to return. (You received this
     *         token from a prior call.)
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public DescribeVpcEndpointsRequest withNextToken(String nextToken) {
        this.nextToken = nextToken;
        return this;
    }

    /**
     * This method is intended for internal use only.
     * Returns the marshaled request configured with additional parameters to
     * enable operation dry-run.
     */
    @Override
    public Request<DescribeVpcEndpointsRequest> getDryRunRequest() {
        Request<DescribeVpcEndpointsRequest> request = new DescribeVpcEndpointsRequestMarshaller().marshall(this);
        request.addParameter("DryRun", Boolean.toString(true));
        return request;
    }

    /**
     * Returns a string representation of this object; useful for testing and
     * debugging.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getVpcEndpointIds() != null) sb.append("VpcEndpointIds: " + getVpcEndpointIds() + ",");
        if (getFilters() != null) sb.append("Filters: " + getFilters() + ",");
        if (getMaxResults() != null) sb.append("MaxResults: " + getMaxResults() + ",");
        if (getNextToken() != null) sb.append("NextToken: " + getNextToken() );
        sb.append("}");
        return sb.toString();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getVpcEndpointIds() == null) ? 0 : getVpcEndpointIds().hashCode());
        hashCode = prime * hashCode + ((getFilters() == null) ? 0 : getFilters().hashCode());
        hashCode = prime * hashCode + ((getMaxResults() == null) ? 0 : getMaxResults().hashCode());
        hashCode = prime * hashCode + ((getNextToken() == null) ? 0 : getNextToken().hashCode());
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        if (obj instanceof DescribeVpcEndpointsRequest == false) return false;
        DescribeVpcEndpointsRequest other = (DescribeVpcEndpointsRequest)obj;

        if (other.getVpcEndpointIds() == null ^ this.getVpcEndpointIds() == null) return false;
        if (other.getVpcEndpointIds() != null && other.getVpcEndpointIds().equals(this.getVpcEndpointIds()) == false) return false;
        if (other.getFilters() == null ^ this.getFilters() == null) return false;
        if (other.getFilters() != null && other.getFilters().equals(this.getFilters()) == false) return false;
        if (other.getMaxResults() == null ^ this.getMaxResults() == null) return false;
        if (other.getMaxResults() != null && other.getMaxResults().equals(this.getMaxResults()) == false) return false;
        if (other.getNextToken() == null ^ this.getNextToken() == null) return false;
        if (other.getNextToken() != null && other.getNextToken().equals(this.getNextToken()) == false) return false;
        return true;
    }

    @Override
    public DescribeVpcEndpointsRequest clone() {

            return (DescribeVpcEndpointsRequest) super.clone();
    }

}


text:
using System;
using System.Windows.Input;
using DBTM.Application.Views;

namespace DBTM.Application.ViewModels
{
    public class AboutCommand  :ICommand
    {
        private readonly IMainWindowView _view;

        public AboutCommand(IMainWindowView view)
        {
            _view = view;
        }

        public void Execute(object parameter)
        {
           _view.ShowAboutDialog();

        }

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public event EventHandler CanExecuteChanged;
    }
}


text:
/******************************************************************************
 *
 * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
 *              $Revision: 122 $
 *
 *****************************************************************************/

/******************************************************************************
 *
 * 1. Copyright Notice
 *
 * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
 * All rights reserved.
 *
 * 2. License
 *
 * 2.1. This is your license from Intel Corp. under its intellectual property
 * rights.  You may have additional license terms from the party that provided
 * you this software, covering your right to use that party's intellectual
 * property rights.
 *
 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
 * copy of the source code appearing in this file ("Covered Code") an
 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
 * base code distributed originally by Intel ("Original Intel Code") to copy,
 * make derivatives, distribute, use and display any portion of the Covered
 * Code in any form, with the right to sublicense such rights; and
 *
 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
 * license (with the right to sublicense), under only those claims of Intel
 * patents that are infringed by the Original Intel Code, to make, use, sell,
 * offer to sell, and import the Covered Code and derivative works thereof
 * solely to the minimum extent necessary to exercise the above copyright
 * license, and in no event shall the patent license extend to any additions
 * to or modifications of the Original Intel Code.  No other license or right
 * is granted directly or by implication, estoppel or otherwise;
 *
 * The above copyright and patent license is granted only if the following
 * conditions are met:
 *
 * 3. Conditions
 *
 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
 * Redistribution of source code of any substantial portion of the Covered
 * Code or modification with rights to further distribute source must include
 * the above Copyright Notice, the above License, this list of Conditions,
 * and the following Disclaimer and Export Compliance provision.  In addition,
 * Licensee must cause all Covered Code to which Licensee contributes to
 * contain a file documenting the changes Licensee made to create that Covered
 * Code and the date of any change.  Licensee must include in that file the
 * documentation of any changes made by any predecessor Licensee.  Licensee
 * must include a prominent statement that the modification is derived,
 * directly or indirectly, from Original Intel Code.
 *
 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
 * Redistribution of source code of any substantial portion of the Covered
 * Code or modification without rights to further distribute source must
 * include the following Disclaimer and Export Compliance provision in the
 * documentation and/or other materials provided with distribution.  In
 * addition, Licensee may not authorize further sublicense of source of any
 * portion of the Covered Code, and must include terms to the effect that the
 * license from Licensee to its licensee is limited to the intellectual
 * property embodied in the software Licensee provides to its licensee, and
 * not to intellectual property embodied in modifications its licensee may
 * make.
 *
 * 3.3. Redistribution of Executable. Redistribution in executable form of any
 * substantial portion of the Covered Code or modification must reproduce the
 * above Copyright Notice, and the following Disclaimer and Export Compliance
 * provision in the documentation and/or other materials provided with the
 * distribution.
 *
 * 3.4. Intel retains all right, title, and interest in and to the Original
 * Intel Code.
 *
 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
 * Intel shall be used in advertising or otherwise to promote the sale, use or
 * other dealings in products derived from or relating to the Covered Code
 * without prior written authorization from Intel.
 *
 * 4. Disclaimer and Export Compliance
 *
 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
 * PARTICULAR PURPOSE.
 *
 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
 * LIMITED REMEDY.
 *
 * 4.3. Licensee shall not export, either directly or indirectly, any of this
 * software or system incorporating such software without first obtaining any
 * required license or other approval from the U. S. Department of Commerce or
 * any other agency or department of the United States Government.  In the
 * event Licensee exports any such software from the United States or
 * re-exports any such software from a foreign destination, Licensee shall
 * ensure that the distribution and export/re-export of the software is in
 * compliance with all laws, regulations, orders, or other restrictions of the
 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 * any of its subsidiaries will export/re-export any technical data, process,
 * software, or service, directly or indirectly, to any country for which the
 * United States government or any agency thereof requires an export license,
 * other governmental approval, or letter of assurance, without first obtaining
 * such license, approval or letter.
 *
 *****************************************************************************/

#define __EXPREP_C__

#include "acpi.h"
#include "acinterp.h"
#include "amlcode.h"
#include "acnamesp.h"

#define _COMPONENT          ACPI_EXECUTER
        ACPI_MODULE_NAME    ("exprep")

/*******************************************************************************
 *
 * FUNCTION:    AcpiExDecodeFieldAccess
 *
 * PARAMETERS:  Access          - Encoded field access bits
 *              Length          - Field length.
 *
 * RETURN:      Field granularity (8, 16, 32 or 64) and
 *              ByteAlignment (1, 2, 3, or 4)
 *
 * DESCRIPTION: Decode the AccessType bits of a field definition.
 *
 ******************************************************************************/

static UINT32
AcpiExDecodeFieldAccess (
    ACPI_OPERAND_OBJECT     *ObjDesc,
    UINT8                   FieldFlags,
    UINT32                  *ReturnByteAlignment)
{
    UINT32                  Access;
    UINT8                   ByteAlignment;
    UINT8                   BitLength;
/*    UINT32                  Length; */

    ACPI_FUNCTION_NAME ("ExDecodeFieldAccess");

    Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);

    switch (Access)
    {
    case AML_FIELD_ACCESS_ANY:

        ByteAlignment = 1;
        BitLength = 8;

#if 0
        /*
         * TBD: optimize
         *
         * Any attempt to optimize the access size to the size of the field
         * must take into consideration the length of the region and take
         * care that an access to the field will not attempt to access
         * beyond the end of the region.
         */

        /* Use the length to set the access type */

        Length = ObjDesc->CommonField.BitLength;

        if (Length <= 8)
        {
            BitLength = 8;
        }
        else if (Length <= 16)
        {
            BitLength = 16;
        }
        else if (Length <= 32)
        {
            BitLength = 32;
        }
        else if (Length <= 64)
        {
            BitLength = 64;
        }
        else
        {
            /* Larger than Qword - just use byte-size chunks */

            BitLength = 8;
        }
#endif
        break;

    case AML_FIELD_ACCESS_BYTE:
    case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
        ByteAlignment = 1;
        BitLength     = 8;
        break;

    case AML_FIELD_ACCESS_WORD:
        ByteAlignment = 2;
        BitLength     = 16;
        break;

    case AML_FIELD_ACCESS_DWORD:
        ByteAlignment = 4;
        BitLength     = 32;
        break;

    case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
        ByteAlignment = 8;
        BitLength     = 64;
        break;

    default:
        /* Invalid field access type */

        ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
            "Unknown field access type %X\n",
            Access));
        return (0);
    }

    if (ACPI_GET_OBJECT_TYPE (ObjDesc) == ACPI_TYPE_BUFFER_FIELD)
    {
        /*
         * BufferField access can be on any byte boundary, so the
         * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
         * implied by the field access type.
         */
        ByteAlignment = 1;
    }

    *ReturnByteAlignment = ByteAlignment;
    return (BitLength);
}

/*******************************************************************************
 *
 * FUNCTION:    AcpiExPrepCommonFieldObject
 *
 * PARAMETERS:  ObjDesc             - The field object
 *              FieldFlags          - Access, LockRule, and UpdateRule.
 *                                    The format of a FieldFlag is described
 *                                    in the ACPI specification
 *              FieldBitPosition    - Field start position
 *              FieldBitLength      - Field length in number of bits
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Initialize the areas of the field object that are common
 *              to the various types of fields.  Note: This is very "sensitive"
 *              code because we are solving the general case for field
 *              alignment.
 *
 ******************************************************************************/

ACPI_STATUS
AcpiExPrepCommonFieldObject (
    ACPI_OPERAND_OBJECT     *ObjDesc,
    UINT8                   FieldFlags,
    UINT8                   FieldAttribute,
    UINT32                  FieldBitPosition,
    UINT32                  FieldBitLength)
{
    UINT32                  AccessBitWidth;
    UINT32                  ByteAlignment;
    UINT32                  NearestByteAddress;

    ACPI_FUNCTION_TRACE ("ExPrepCommonFieldObject");

    /*
     * Note: the structure being initialized is the
     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
     * area are initialized by this procedure.
     */
    ObjDesc->CommonField.FieldFlags = FieldFlags;
    ObjDesc->CommonField.Attribute  = FieldAttribute;
    ObjDesc->CommonField.BitLength  = FieldBitLength;

    /*
     * Decode the access type so we can compute offsets.  The access type gives
     * two pieces of information - the width of each field access and the
     * necessary ByteAlignment (address granularity) of the access.
     *
     * For AnyAcc, the AccessBitWidth is the largest width that is both
     * necessary and possible in an attempt to access the whole field in one
     * I/O operation.  However, for AnyAcc, the ByteAlignment is always one
     * byte.
     *
     * For all Buffer Fields, the ByteAlignment is always one byte.
     *
     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
     * the same (equivalent) as the ByteAlignment.
     */
    AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags,
                                &ByteAlignment);
    if (!AccessBitWidth)
    {
        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
    }

    /* Setup width (access granularity) fields */

    ObjDesc->CommonField.AccessByteWidth = (UINT8)
            ACPI_DIV_8 (AccessBitWidth); /* 1,  2,  4,  8 */

    /*
     * BaseByteOffset is the address of the start of the field within the
     * region.  It is the byte address of the first *datum* (field-width data
     * unit) of the field. (i.e., the first datum that contains at least the
     * first *bit* of the field.)
     *
     * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
     * (Byte access), and it defines the addressing granularity of the parent
     * region or buffer.
     */
    NearestByteAddress =
            ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
    ObjDesc->CommonField.BaseByteOffset =
            ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);

    /*
     * StartFieldBitOffset is the offset of the first bit of the field within
     * a field datum.
     */
    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));

    /*
     * Valid bits -- the number of bits that compose a partial datum,
     * 1) At the end of the field within the region (arbitrary starting bit
     *    offset)
     * 2) At the end of a buffer used to contain the field (starting offset
     *    always zero)
     */
    ObjDesc->CommonField.EndFieldValidBits   = (UINT8)
        ((ObjDesc->CommonField.StartFieldBitOffset + FieldBitLength) %
                                                            AccessBitWidth);
    /* StartBufferBitOffset always = 0 */

    ObjDesc->CommonField.EndBufferValidBits  = (UINT8)
        (FieldBitLength % AccessBitWidth);

    /*
     * DatumValidBits is the number of valid field bits in the first
     * field datum.
     */
    ObjDesc->CommonField.DatumValidBits      = (UINT8)
        (AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset);

    /*
     * Does the entire field fit within a single field access element? (datum)
     * (i.e., without crossing a datum boundary)
     */
    if ((ObjDesc->CommonField.StartFieldBitOffset + FieldBitLength) <=
            (UINT16) AccessBitWidth)
    {
        ObjDesc->Common.Flags |= AOPOBJ_SINGLE_DATUM;
    }

    return_ACPI_STATUS (AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    AcpiExPrepFieldValue
 *
 * PARAMETERS:  Node                - Owning Node
 *              RegionNode          - Region in which field is being defined
 *              FieldFlags          - Access, LockRule, and UpdateRule.
 *              FieldBitPosition    - Field start position
 *              FieldBitLength      - Field length in number of bits
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type DefField and
 *              connect it to the parent Node.
 *
 ******************************************************************************/

ACPI_STATUS
AcpiExPrepFieldValue (
    ACPI_CREATE_FIELD_INFO  *Info)
{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    UINT32                  Type;
    ACPI_STATUS             Status;

    ACPI_FUNCTION_TRACE ("ExPrepFieldValue");

    /* Parameter validation */

    if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
    {
        if (!Info->RegionNode)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null RegionNode\n"));
            return_ACPI_STATUS (AE_AML_NO_OPERAND);
        }

        Type = AcpiNsGetType (Info->RegionNode);
        if (Type != ACPI_TYPE_REGION)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
                "Needed Region, found type %X %s\n",
                Type, AcpiUtGetTypeName (Type)));

            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
    }

    /* Allocate a new field object */

    ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }

    /* Initialize areas of the object that are common to all fields */

    ObjDesc->CommonField.Node = Info->FieldNode;
    Status = AcpiExPrepCommonFieldObject (ObjDesc, Info->FieldFlags,
                Info->Attribute, Info->FieldBitPosition, Info->FieldBitLength);
    if (ACPI_FAILURE (Status))
    {
        AcpiUtDeleteObjectDesc (ObjDesc);
        return_ACPI_STATUS (Status);
    }

    /* Initialize areas of the object that are specific to the field type */

    switch (Info->FieldType)
    {
    case ACPI_TYPE_LOCAL_REGION_FIELD:

        ObjDesc->Field.RegionObj     = AcpiNsGetAttachedObject (Info->RegionNode);

        /* An additional reference for the container */

        AcpiUtAddReference (ObjDesc->Field.RegionObj);

        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "RegionField: Bitoff=%X Off=%X Gran=%X Region %p\n",
            ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset,
            ObjDesc->Field.AccessByteWidth, ObjDesc->Field.RegionObj));
        break;

    case ACPI_TYPE_LOCAL_BANK_FIELD:

        ObjDesc->BankField.Value     = Info->BankValue;
        ObjDesc->BankField.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
        ObjDesc->BankField.BankObj   = AcpiNsGetAttachedObject (Info->RegisterNode);

        /* An additional reference for the attached objects */

        AcpiUtAddReference (ObjDesc->BankField.RegionObj);
        AcpiUtAddReference (ObjDesc->BankField.BankObj);

        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "Bank Field: BitOff=%X Off=%X Gran=%X Region %p BankReg %p\n",
            ObjDesc->BankField.StartFieldBitOffset,
            ObjDesc->BankField.BaseByteOffset,
            ObjDesc->Field.AccessByteWidth,
            ObjDesc->BankField.RegionObj,
            ObjDesc->BankField.BankObj));
        break;

    case ACPI_TYPE_LOCAL_INDEX_FIELD:

        ObjDesc->IndexField.IndexObj = AcpiNsGetAttachedObject (Info->RegisterNode);
        ObjDesc->IndexField.DataObj  = AcpiNsGetAttachedObject (Info->DataRegisterNode);
        ObjDesc->IndexField.Value    = (UINT32)
            (Info->FieldBitPosition / ACPI_MUL_8 (ObjDesc->Field.AccessByteWidth));

        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Index Object\n"));
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }

        /* An additional reference for the attached objects */

        AcpiUtAddReference (ObjDesc->IndexField.DataObj);
        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);

        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "IndexField: bitoff=%X off=%X gran=%X Index %p Data %p\n",
            ObjDesc->IndexField.StartFieldBitOffset,
            ObjDesc->IndexField.BaseByteOffset,
            ObjDesc->Field.AccessByteWidth,
            ObjDesc->IndexField.IndexObj,
            ObjDesc->IndexField.DataObj));
        break;

    default:
        /* No other types should get here */
        break;
    }

    /*
     * Store the constructed descriptor (ObjDesc) into the parent Node,
     * preserving the current type of that NamedObj.
     */
    Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc,
                    AcpiNsGetType (Info->FieldNode));

    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "set NamedObj %p (%4.4s) val = %p\n",
            Info->FieldNode, Info->FieldNode->Name.Ascii, ObjDesc));

    /* Remove local reference to the object */

    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}


text:
#include "config.h"

#if ENABLE(NETSCAPE_PLUGIN_API)

#include "c_utility.h"

#include "CRuntimeObject.h"
#include "JSDOMBinding.h"
#include "JSDOMWindow.h"
#include "NP_jsobject.h"
#include "c_instance.h"
#include <runtime/JSGlobalObject.h>
#include <runtime/JSLock.h>
#include "npruntime_impl.h"
#include "npruntime_priv.h"
#include "runtime_object.h"
#include "runtime_root.h"
#include <wtf/Assertions.h>
#include <wtf/text/WTFString.h>

namespace JSC { namespace Bindings {

static String convertUTF8ToUTF16WithLatin1Fallback(const NPUTF8* UTF8Chars, int UTF8Length)
{
    ASSERT(UTF8Chars || UTF8Length == 0);

    if (UTF8Length == -1)
        UTF8Length = static_cast<int>(strlen(UTF8Chars));

    String result = String::fromUTF8(UTF8Chars, UTF8Length);

    // If we got back a null string indicating an unsuccessful conversion, fall back to latin 1.
    // Some plugins return invalid UTF-8 in NPVariantType_String, see <http://bugs.webkit.org/show_bug.cgi?id=5163>
    // There is no "bad data" for latin1. It is unlikely that the plugin was really sending text in this encoding,
    // but it should have used UTF-8, and now we are simply avoiding a crash.
    if (result.isNull())
        result = String(UTF8Chars, UTF8Length);

    return result;
}

// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValue value, NPVariant* result)
{
    JSLockHolder lock(exec);

    VOID_TO_NPVARIANT(*result);

    if (value.isString()) {
        String ustring = value.toString(exec)->value(exec);
        CString cstring = ustring.utf8();
        NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) };
        NPN_InitializeVariantWithStringCopy(result, &string);
    } else if (value.isNumber()) {
        DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
    } else if (value.isBoolean()) {
        BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
    } else if (value.isNull()) {
        NULL_TO_NPVARIANT(*result);
    } else if (value.isObject()) {
        JSObject* object = asObject(value);
        if (object->classInfo() == CRuntimeObject::info()) {
            CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object);
            CInstance* instance = runtimeObject->getInternalCInstance();
            if (instance) {
                NPObject* obj = instance->getObject();
                _NPN_RetainObject(obj);
                OBJECT_TO_NPVARIANT(obj, *result);
            }
        } else {
            JSGlobalObject* globalObject = exec->dynamicGlobalObject();

            RootObject* rootObject = findRootObject(globalObject);
            if (rootObject) {
                NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
                OBJECT_TO_NPVARIANT(npObject, *result);
            }
        }
    }
}

JSValue convertNPVariantToValue(ExecState* exec, const NPVariant* variant, RootObject* rootObject)
{
    JSLockHolder lock(exec);

    NPVariantType type = variant->type;

    if (type == NPVariantType_Bool)
        return jsBoolean(NPVARIANT_TO_BOOLEAN(*variant));
    if (type == NPVariantType_Null)
        return jsNull();
    if (type == NPVariantType_Void)
        return jsUndefined();
    if (type == NPVariantType_Int32)
        return jsNumber(NPVARIANT_TO_INT32(*variant));
    if (type == NPVariantType_Double)
        return jsNumber(NPVARIANT_TO_DOUBLE(*variant));
    if (type == NPVariantType_String)
        return WebCore::jsStringWithCache(exec, convertNPStringToUTF16(&variant->value.stringValue));
    if (type == NPVariantType_Object) {
        NPObject* obj = variant->value.objectValue;

        if (obj->_class == NPScriptObjectClass)
            // Get JSObject from NP_JavaScriptObject.
            return ((JavaScriptObject*)obj)->imp;

        // Wrap NPObject in a CInstance.
        return CInstance::create(obj, rootObject)->createRuntimeObject(exec);
    }

    return jsUndefined();
}

String convertNPStringToUTF16(const NPString* string)
{
    return String::fromUTF8WithLatin1Fallback(string->UTF8Characters, string->UTF8Length);
}

Identifier identifierFromNPIdentifier(ExecState* exec, const NPUTF8* name)
{
    return Identifier(exec, convertUTF8ToUTF16WithLatin1Fallback(name, -1));
}

} }

#endif // ENABLE(NETSCAPE_PLUGIN_API)


text:
package org.pentaho.di.core.plugins;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.util.List;
import java.util.Map;

import org.apache.commons.vfs.FileObject;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.annotations.JobEntry;
import org.pentaho.di.core.exception.KettlePluginException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.vfs.KettleVFS;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.job.entry.JobEntryInterface;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 * This plugin type handles the job entries.
 *
 * @author matt
 *
 */

@PluginTypeCategoriesOrder(getNaturalCategoriesOrder={
     "JobCategory.Category.General"
    ,"JobCategory.Category.Mail"
    ,"JobCategory.Category.FileManagement"
    ,"JobCategory.Category.Conditions"
    ,"JobCategory.Category.Scripting"
    ,"JobCategory.Category.BulkLoading"
    ,"JobCategory.Category.BigData"
    ,"JobCategory.Category.DataQuality"
    ,"JobCategory.Category.XML"
    ,"JobCategory.Category.Utility"
    ,"JobCategory.Category.Repository"
    ,"JobCategory.Category.FileTransfer"
    ,"JobCategory.Category.FileEncryption"
    ,"JobCategory.Category.Palo"
    ,"JobCategory.Category.Experimental"
},
   i18nPackageClass = JobMeta.class)
@PluginMainClassType(JobEntryInterface.class)
@PluginAnnotationType(JobEntry.class)
public class JobEntryPluginType extends BasePluginType implements PluginTypeInterface {
	private static Class<?> PKG = JobMeta.class; // for i18n purposes, needed by Translator2!!   $NON-NLS-1$

  public static final String GENERAL_CATEGORY = BaseMessages.getString(PKG, "JobCategory.Category.General");

	private static JobEntryPluginType pluginType;

	private JobEntryPluginType() {
		super(JobEntry.class, "JOBENTRY", "Job entry");
		populateFolders("jobentries");
	}

	public static JobEntryPluginType getInstance() {
		if (pluginType==null) {
			pluginType=new JobEntryPluginType();
		}
		return pluginType;
	}

	/**
	 * Let's put in code here to search for the step plugins..
	 */
	public void searchPlugins() throws KettlePluginException {
		registerNatives();
		registerAnnotations();
		registerPluginJars();
		registerXmlPlugins();
	}

	/**
	 * Scan & register internal step plugins
	 */
	protected void registerNatives() throws KettlePluginException {
		// Scan the native steps...
		//
		String kettleJobEntriesXmlFile = Const.XML_FILE_KETTLE_JOB_ENTRIES;
    String alternative = System.getProperty(Const.KETTLE_CORE_JOBENTRIES_FILE, null);
    if (!Const.isEmpty(alternative)) {
      kettleJobEntriesXmlFile = alternative;
    }

		// Load the plugins for this file...
		//
		try {
			InputStream inputStream = getClass().getResourceAsStream(kettleJobEntriesXmlFile);
			if (inputStream==null) {
				inputStream =  getClass().getResourceAsStream("/"+kettleJobEntriesXmlFile);
			}
	     // Retry to load a regular file...
      if (inputStream==null && !Const.isEmpty(alternative)) {
        try {
          inputStream = new FileInputStream(kettleJobEntriesXmlFile);
        } catch(Exception e) {
          throw new KettlePluginException("Unable to load native job entries plugins '"+kettleJobEntriesXmlFile+"'", e);
        }
      }
			if (inputStream==null) {
				throw new KettlePluginException("Unable to find native step definition file: "+Const.XML_FILE_KETTLE_JOB_ENTRIES);
			}
			Document document = XMLHandler.loadXMLFile(inputStream, null, true, false);

			// Document document = XMLHandler.loadXMLFile(kettleStepsXmlFile);

			Node entriesNode = XMLHandler.getSubNode(document, "job-entries");
			List<Node> entryNodes = XMLHandler.getNodes(entriesNode, "job-entry");
			for (Node entryNode : entryNodes) {
				registerPluginFromXmlResource(entryNode, null, this.getClass(), true, null);
			}

		} catch (KettleXMLException e) {
			throw new KettlePluginException("Unable to read the kettle job entries XML config file: "+kettleJobEntriesXmlFile, e);
		}
	}

	/**
	 * Scan & register internal job entry plugins
	 */
	protected void registerAnnotations() throws KettlePluginException {
		// This is no longer done because it was deemed too slow.  Only jar files in the plugins/ folders are scanned for annotations.
	}

	protected void registerXmlPlugins() throws KettlePluginException {
		for (PluginFolderInterface folder : pluginFolders) {

			if (folder.isPluginXmlFolder()) {
				List<FileObject> pluginXmlFiles = findPluginXmlFiles(folder.getFolder());
				for (FileObject file : pluginXmlFiles) {

					try {
						Document document = XMLHandler.loadXMLFile(file);
						Node pluginNode = XMLHandler.getSubNode(document, "plugin");

						registerPluginFromXmlResource(pluginNode, KettleVFS.getFilename(file.getParent()), this.getClass(), false, file.getParent().getURL());
					} catch(Exception e) {
						// We want to report this plugin.xml error, perhaps an XML typo or something like that...
						//
						log.logError("Error found while reading job entry plugin.xml file: "+file.getName().toString(), e);
					}
				}
			}
		}
	}

  @Override
  protected String extractCategory(Annotation annotation) {
    return ((JobEntry) annotation).categoryDescription();
  }

  @Override
  protected String extractDesc(Annotation annotation) {
    return ((JobEntry) annotation).description();
  }

  @Override
  protected String extractID(Annotation annotation) {
    return ((JobEntry) annotation).id();
  }

  @Override
  protected String extractName(Annotation annotation) {
    return ((JobEntry) annotation).name();
  }

  @Override
  protected String extractImageFile(Annotation annotation) {
    return ((JobEntry) annotation).image();
  }

  @Override
  protected boolean extractSeparateClassLoader(Annotation annotation) {
    return false;
  }

  @Override
  protected String extractI18nPackageName(Annotation annotation) {
    return ((JobEntry) annotation).i18nPackageName();
  }

  @Override
  protected void addExtraClasses(Map<Class<?>, String> classMap, Class<?> clazz, Annotation annotation) {
  }

  @Override
  protected String extractDocumentationUrl(Annotation annotation) {
    return ((JobEntry)annotation).documentationUrl();
  }

  @Override
  protected String extractCasesUrl(Annotation annotation) {
    return ((JobEntry)annotation).casesUrl();
  }

  @Override
  protected String extractForumUrl(Annotation annotation) {
    return ((JobEntry)annotation).forumUrl();
  }

}


text:
/**
 * Created by cturner on 07/10/2016.
 */
import {HostBinding, Directive, Input, HostListener, ElementRef} from "@angular/core";
import {MenuComponent} from "../menu.component";
import {PositionContent} from "../../core/position/position-content";
import {PositionStrategy} from "../../core/position/position-strategy";
@Directive({
    selector: '[primal-menu-trigger]'
})
export class MenuTrigger {
    @Input() menuPositionX: PositionContent = "onAndAfter";
    @Input() menuPositionY: PositionContent = "after";

    @Input('primal-menu-trigger') menu: MenuComponent;

    constructor(private elementRef: ElementRef) {}

    @HostBinding('attr.aria-haspopup')
    hasPopUp: boolean = true;

    @HostListener('click', ['$event'])
    click($event: MouseEvent | KeyboardEvent) {
        this.menu.trigger(this.elementRef, new PositionStrategy(this.menuPositionX, this.menuPositionY));
    }
}


text:
YUI.add('slider-value-range', function(Y) {

/**
 * Adds value support for Slider as a range of integers between a configured
 * minimum and maximum value.  For use with Y.Base.build(..) to
 * add the plumbing to Y.SliderBase.
 *
 * @module slider
 * @submodule slider-value-range
 */

// Constants for compression or performance
var MIN       = 'min',
    MAX       = 'max',
    VALUE     = 'value',

    round = Math.round;

/**
 * One class of value algorithm that can be built onto SliderBase.  By default,
 * values range between 0 and 100, but you can configure these on the
 * built Slider class by setting the min and max
 * configurations.  Set the initial value (will cause the thumb to move to the
 * appropriate location on the rail) in configuration as well if appropriate.
 *
 * @class SliderValueRange
 */
function SliderValueRange() {
    this._initSliderValueRange();
}

Y.SliderValueRange = Y.mix( SliderValueRange, {

    // Prototype properties and methods that will be added onto host class
    prototype: {
        /**
         * Cached X or Y offset for the rail to avoid extraneous
         * getXY() calls during run time calculation.
         *
         * @property _offsetXY
         * @type {Number}
         * @protected
         */
        _offsetXY: null,

        /**
         * Factor used to translate value -> position -> value.
         *
         * @property _factor
         * @type {Number}
         * @protected
         */
        _factor: 1,

        /**
         * Attach event listeners to keep the UI in sync with the min/max/value
         * attributes and thumb position.
         *
         * @method _initSliderValueRange
         * @protected
         */
        _initSliderValueRange: function () {
            this._key = this._key || {};

            Y.mix( this._key, ( this.axis === 'y' ) ?
                {
                    minEdge : 'top',
                    maxEdge : 'bottom',
                    xyIndex : 1
                } :
                {
                    minEdge : 'left',
                    maxEdge : 'right',
                    xyIndex : 0
                } );
        },

        /**
         * Override of stub method in SliderBase that is called at the end of
         * its bindUI stage of render().  Subscribes to internal events to
         * trigger UI and related state updates.
         *
         * @method _bindValueLogic
         * @protected
         */
        _bindValueLogic: function () {
            this.after( {
                minChange  : this._afterMinChange,
                maxChange  : this._afterMaxChange,
                valueChange: this._afterValueChange
            } );
        },

        /**
         * Move the thumb to appropriate position if necessary.  Also resets
         * the cached offsets and recalculates the conversion factor to
         * translate position to value.
         *
         * @method _syncThumbPosition
         * @protected
         */
        _syncThumbPosition: function () {
            this._cacheRailOffset();

            this._calculateFactor();

            this._setPosition( this.get( VALUE ) );
        },

        /**
         * Captures the current top left of the rail to avoid excessive DOM
         * lookups at run time.
         *
         * @method _cacheRailOffset
         * @protected
         */
        _cacheRailOffset: function () {
            var region = this._dd.con.getRegion();
            this._offsetXY = region[ this._key.minEdge ];
        },

        /**
         * Calculates and caches
         * (range between max and min) / (rail width or height)
         * for fast runtime calculation of position -> value.
         *
         * @method _calculateFactor
         * @protected
         */
        _calculateFactor: function () {
            var region = this._dd.con.getRegion( true );

            // e.g. ( max - min ) / ( constrain.right - constrain.left )
            this._factor =
                ( this.get( MAX ) - this.get( MIN ) ) /
                ( region[ this._key.maxEdge ] - region[ this._key.minEdge ] );
        },

        /**
         * Dispatch the new position of the thumb into the value setting
         * operations.
         *
         * @method _defThumbMoveFn
         * @param e { EventFacade } The host's thumbMove event
         * @protected
         */
        _defThumbMoveFn: function ( e ) {
            var previous = this.get( VALUE ),
                position = this._dd.actXY[ this._key.xyIndex ],
                value    = this._offsetToValue( position );

            // Can't just do this.set( VALUE, this._offsetToValue( value ) )
            if ( previous !== value ) {
                this.set( VALUE, value, { ddEvent: e.ddEvent } );
            }
        },

        /**
         *
Converts a pixel position into a value.  Calculates current
         * position minus xy offsets of the rail multiplied by the
         * ratio of (max - min) / (constraining dim).

         *
         *
Override this if you want to use a different value mapping
         * algorithm.

         *
         * @method _offsetToValue
         * @param { Number } X or Y pixel position
         * @return { mixed } Value corresponding to the provided pixel position
         * @protected
         */
        _offsetToValue: function ( xy ) {
            xy -= this._offsetXY;

            var value = round( xy * this._factor ) + this.get( MIN );

            return this._nearestValue( value );
        },

        /**
         * Converts a value into a positional pixel value for use in positioning
         * the thumb according to the reverse of the
         * _offsetToValue( xy ) operation.
         *
         * @method _valueToOffset
         * @param val { Number } The value to map to pixel X or Y position
         * @return { Array } [ Xpx, Ypx ] positional values
         * @protected
         */
        _valueToOffset: function ( value ) {
            value -= this.get( MIN );

            return round( value / this._factor ) + this._offsetXY;
        },

        /**
         * Update position according to new min value.  If the new min results
         * in the current value being out of range, the value is set to the
         * closer of min or max.
         *
         * @method _afterMinChange
         * @param e { EventFacade } The min attribute change event.
         * @protected
         */
        _afterMinChange: function ( e ) {
            this._verifyValue();

            this._syncThumbPosition();
        },

        /**
         * Update position according to new max value.  If the new max results
         * in the current value being out of range, the value is set to the
         * closer of min or max.
         *
         * @method _afterMaxChange
         * @param e { EventFacade } The max attribute change event.
         * @protected
         */
        _afterMaxChange: function ( e ) {
            this._verifyValue();

            this._syncThumbPosition();
        },

        /**
         * Verifies that the current value is within the min - max range.  If
         * not, value is set to either min or max, depending on which is
         * closer.
         *
         * @method _verifyValue
         * @protected
         */
        _verifyValue: function () {
            var value   = this.get( VALUE ),
                nearest = this._nearestValue( value );

            if ( value !== nearest ) {
                // @TODO Can/should valueChange, minChange, etc be queued
                // events? To make dd.set( 'min', n ); execute after minChange
                // subscribers before on/after valueChange subscribers.
                this.set( VALUE, nearest );
            }
        },

        /**
         * Propagate change to the thumb position unless the change originated
         * from the thumbMove event.
         *
         * @method _afterValueChange
         * @param e { EventFacade } The valueChange event.
         * @protected
         */
        _afterValueChange: function ( e ) {
            if ( !e.ddEvent ) {
                this._setPosition( e.newVal );
            }
        },

        /**
         * Positions the thumb in accordance with the translated value.
         *
         * @method _setPosition
         * @protected
         */
        _setPosition: function ( value ) {
            var thumb = this._dd;

            // Drag element hasn't been setup yet
            if ( !thumb.deltaXY ) {
                thumb.actXY = thumb.get( 'dragNode' ).getXY();
                thumb._setStartPosition( thumb.actXY );
            }

            thumb.actXY[ this._key.xyIndex ] = this._valueToOffset( value );

            thumb._moveNode();
        },

        /**
         * Validates new values assigned to min attribute.  Numbers
         * are acceptable.  Override this to enforce different rules.
         *
         * @method _validateNewMin
         * @param value { mixed } Value assigned to min attribute.
         * @return { Boolean } True for numbers.  False otherwise.
         * @protected
         */
        _validateNewMin: function ( value ) {
            return Y.Lang.isNumber( value );
        },

        /**
         * Validates new values assigned to max attribute.  Numbers
         * are acceptable.  Override this to enforce different rules.
         *
         * @method _validateNewMax
         * @param value { mixed } Value assigned to max attribute.
         * @return { Boolean } True for numbers.  False otherwise.
         * @protected
         */
        _validateNewMax: function ( value ) {
            return Y.Lang.isNumber( value );
        },

        /**
         * Validates new values assigned to value attribute.
         * Numbers between the configured min and max
         * are acceptable.
         *
         * @method _validateNewValue
         * @param value { mixed } Value assigned to value attribute
         * @return { Boolean } True if value is a number between the configured
         *                     min and max.
         * @protected
         */
        _validateNewValue: function ( value ) {
            return ( value === this._nearestValue( value ) );
        },

        /**
         * Returns the nearest valid value to the value input.  If the provided
         * value is outside the min - max range, accounting for min > max
         * scenarios, the nearest of either min or max is returned.  Otherwise,
         * the provided value is returned.
         *
         * @method _nearestValue
         * @param value { mixed } Value to test against current min - max range
         * @return { Number } Current min, max, or value if within range
         * @protected
         */
        _nearestValue: function ( value ) {
            var min = this.get( MIN ),
                max = this.get( MAX ),
                tmp;

            // Account for reverse value range (min > max)
            tmp = ( max > min ) ? max : min;
            min = ( max > min ) ? min : max;
            max = tmp;

            return ( value < min ) ?
                    min :
                    ( value > max ) ?
                        max :
                        value;
        }

    },

    /**
     * Attributes that will be added onto host class.
     *
     * @property ATTRS
     * @type {Object}
     * @static
     * @protected
     */
    ATTRS: {
        /**
         * The value associated with the farthest top, left position of the
         * rail.  Can be greater than the configured max if you
         * want values to increase from right-to-left or bottom-to-top.
         *
         * @attribute min
         * @type { Number }
         * @default 0
         */
        min: {
            value    : 0,
            validator: '_validateNewMin'
        },

        /**
         * The value associated with the farthest bottom, right position of
         * the rail.  Can be less than the configured min if
         * you want values to increase from right-to-left or bottom-to-top.
         *
         * @attribute max
         * @type { Number }
         * @default 100
         */
        max: {
            value    : 100,
            validator: '_validateNewMax'
        },

        /**
         * The value associated with the thumb's current position on the
         * rail. Defaults to the value inferred from the thumb's current
         * position. Specifying value in the constructor will move the
         * thumb to the position that corresponds to the supplied value.
         *
         * @attribute value
         * @type { Number }
         * @default (inferred from current thumb position)
         */
        value: {
            value    : 0,
            validator: '_validateNewValue'
        }
    }
}, true );

}, '@VERSION@' ,{requires:['slider-base']});


text:
package pkg;

import java.lang.annotation.*;

/**
 * This annotation is a non-documented annotation container for RegContaineeDoc.
 * It will be used to annotate Class C using a non-synthesized form.
 *
 * @author Bhavesh Patel
 */
public @interface ContainerRegNotDoc {

    RegContaineeDoc[] value();
}