text:
Amazon SQS Extended Client Library for .NET
===========================================

[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://vshymanskyy.github.io/StandWithUkraine)

[![Build status](https://github.com/raol/amazon-sqs-net-extended-client-lib/actions/workflows/dotnet-core-desktop.yml/badge.svg)](https://github.com/raol/amazon-sqs-net-extended-client-lib/actions)

This is port to .NET of existing [Amazon Extended Client Library for Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib)
It enables you to store message payloads in S3 and hence overcomes message size limitation of the SQS.
With this library you can:

* Specify whether message payloads should be always stored in S3 or when message size exceeds configurable threshold.

* Send message and store its payload in S3 bucket.

* Receive stored message from S3 bucket transparently

* Delete stored payload from the S3 bucket.

## Installation

[![Nuget](https://img.shields.io/nuget/v/Amazon.SQS.ExtendedClient.svg?style=flat)](https://www.nuget.org/packages/Amazon.SQS.ExtendedClient/)

To install via nuget, run following command in the Package Manager Console
```PowerShell
Install-Package Amazon.SQS.ExtendedClient
```

## Usage

```csharp
var s3Client = new AmazonS3Client(new BasicAWSCredentials("<key>", "<secret>"), "<region>")
var sqsClient = new AmazonSQSClient(new BasicAWSCredentials("<key>", "<secret>"), "<region>");
var extendedClient = new AmazonSQSExtendedClient(
    sqsClient,
    new ExtendedClientConfiguration().WithLargePayloadSupportEnabled(s3Client, "<s3bucketname>"));
extendedClient.SendMessage(queueUrl, "MessageBody")
```


text:
void runCommand(struct qryData *query) {
  MAC_YIELD

  /* set up the output context */
  if(!outputSetup(query)) {
    query->CMD_RETVAL = EXIT_FAILURE;
  }
  else switch(query->commandMode) {
    case 1: {
      /* get the number of columns in a file */
      query->CMD_RETVAL = getColumnCount(query, query->inputFileName);
    } break;

    case 2: {
      /* get the file offset of the start of the next record in a file */
      query->CMD_RETVAL = getNextRecordOffset(query, query->inputFileName, query->CMD_OFFSET);
    } break;

    case 3: {
      /* get the unescaped value of column X of the record starting at the file offset */
      query->CMD_RETVAL = getColumnValue(
        query,
        query->inputFileName,
        query->CMD_OFFSET,
        query->CMD_COLINDEX);
    } break;

    case 4: {
      /* get the current date in ISO8601 format (local time with UTC offset) */
      char *output = NULL;
      int retval;

      /* get the current date as a string */
      if((retval = getCurrentDate(&output))) {
        /* print the timestamp */
        fputsEncoded(output, query);

        if(query->outputFile == stdout) {
          fputsEncoded(query->newLine, query);
        }

        /* free the string data */
        freeAndZero(output);
      }

      /* quit */
      query->CMD_RETVAL = (retval == 0 ? EXIT_FAILURE : EXIT_SUCCESS);
    } return;

    case 5: {
      /* just output the entire file that's specified, so we can convert between character encodings */
      query->CMD_RETVAL = outputFile(query, query->inputFileName);
    } break;
  }

  freeAndZero(query->inputFileName);
}

redpajama_set_name: RedPajamaGithub


text:
.content-wrapper {
    background: none;
}

.form-control {
    font-size: 0.8rem;
}

body {
    padding-top: 50px;
    padding-bottom: 20px;
}

/* Wrapping element */
/* Set some basic padding to keep content from hitting the edges */
.body-content {
    padding-left: 15px;
    padding-right: 15px;
}

/* Set widths on the form inputs since otherwise they're 100% wide */
input,
select,
textarea {
    max-width: 280px;
}

/* Carousel */
.carousel-caption p {
    font-size: 20px;
    line-height: 1.4;
}

/* Make .svg files in the carousel display properly in older browsers */
/*.carousel-inner .item img[src$=".svg"] {
    width: 100%;
}*/

/* Hide/rearrange for smaller screens */
@media screen and (max-width: 767px) {
    /* Hide captions */
    .carousel-caption {
        display: none;
    }
}

.cm-form-primary {
    max-width: 80rem;
}

.background-panel {
    padding: 10px;
    background: #fff;
    border-radius: 4px;
}

.jsgrid-grid-header,
.jsgrid-grid-body {
    overflow: auto;
}

jsgrid-cell {
    font-size: 13px;
}

th {
    color: #777;
    width: 120px;
    font-weight: 600;
    text-align: right;
    font-size: 12px;
    padding: 7px 15px 7px 15px;
}

td {
    padding: 7px 15px 7px 15px;
    font-size: 12px;
}

/* Style the tab */
div.tab {
    overflow: hidden;
    border: 1px solid #ccc;
    background-color: #f1f1f1;
    border-top-left-radius: 4px;
    border-top-right-radius: 4px;
}

/* Style the buttons inside the tab */
div.tab button {
    background-color: inherit;
    float: left;
    border: none;
    outline: none;
    cursor: pointer;
    padding: 14px 16px;
    transition: 0.3s;
}

    /* Change background color of buttons on hover */
    div.tab button:hover {
        background-color: #ddd;
    }

    /* Create an active/current tablink class */
    div.tab button.active {
        background-color: #ccc;
    }

/* Style the tab content */
.tabcontent {
    display: none;
    padding: 6px 12px;
    border: 1px solid #ccc;
    border-top: none;
    border-bottom-left-radius: 4px;
    border-bottom-right-radius: 4px;
    background-color: #fff;
}

.jsgrid-cell {
    overflow: hidden;
}

li.hr {
    border-bottom: 1px solid #007bff;
}


text:
package org.sablecc.sablecc.oldlrautomaton;

import java.util.*;

import org.sablecc.exception.*;

public class Item
        implements Ahead {

    private final OldAlternative oldAlternative;

    private final int position;

    private final ItemType itemType;

    Item(
            OldAlternative oldAlternative,
            int position,
            ItemType itemType) {

        this.oldAlternative = oldAlternative;
        this.position = position;
        this.itemType = itemType;
    }

    public ItemType getType() {

        return this.itemType;
    }

    public OldProductionElement getProductionElement() {

        if (this.itemType != ItemType.BEFORE_PRODUCTION) {
            throw new InternalException("invalid call");
        }

        return (OldProductionElement) this.oldAlternative
                .getElement(this.position);
    }

    public OldTokenElement getTokenElement() {

        if (this.itemType != ItemType.BEFORE_TOKEN) {
            throw new InternalException("invalid call");
        }

        return (OldTokenElement) this.oldAlternative.getElement(this.position);
    }

    public Item next() {

        return this.oldAlternative.getItem(this.position + 1);
    }

    @Override
    public String toString() {

        return this.oldAlternative.getFullName() + ":" + this.position;
    }

    public OldAlternative getAlternative() {

        return this.oldAlternative;
    }

    public int getPosition() {

        return this.position;
    }

    public Set<Ahead> look(
            int distance) {

        if (distance < 1) {
            throw new InternalException("invalid distance");
        }

        if (this.position == this.oldAlternative.getElements().size()) {
            Set<Ahead> result = new LinkedHashSet<Ahead>();
            result.add(Farther.get(distance));
            return result;
        }

        OldElement oldElement = this.oldAlternative.getElement(this.position);
        if (oldElement instanceof OldTokenElement) {
            if (distance == 1) {
                Set<Ahead> result = new LinkedHashSet<Ahead>();
                result.add(this);
                return result;
            }

            return next().look(distance - 1);
        }

        OldProductionElement oldProductionElement = (OldProductionElement) oldElement;
        OldProduction oldProduction = oldProductionElement.getProduction();
        Set<Ahead> result = new LinkedHashSet<Ahead>();
        for (Ahead ahead : oldProduction.look(distance)) {
            if (ahead instanceof Item) {
                result.add(ahead);
            }
            else {
                Farther farther = (Farther) ahead;
                result.addAll(next().look(farther.getDistance()));
            }
        }
        return result;
    }

    public Set<Ahead> tryLook(
            int distance) {

        if (distance < 1) {
            throw new InternalException("invalid distance");
        }

        if (this.position == this.oldAlternative.getElements().size()) {
            Set<Ahead> result = new LinkedHashSet<Ahead>();
            result.add(Farther.get(distance));
            return result;
        }

        OldElement oldElement = this.oldAlternative.getElement(this.position);
        if (oldElement instanceof OldTokenElement) {
            if (distance == 1) {
                Set<Ahead> result = new LinkedHashSet<Ahead>();
                result.add(this);
                return result;
            }

            return next().tryLook(distance - 1);
        }

        OldProductionElement oldProductionElement = (OldProductionElement) oldElement;
        OldProduction oldProduction = oldProductionElement.getProduction();
        Set<Ahead> result = new LinkedHashSet<Ahead>();
        for (Ahead ahead : oldProduction.tryLook(distance)) {
            if (ahead instanceof Item) {
                result.add(ahead);
            }
            else {
                Farther farther = (Farther) ahead;
                result.addAll(next().tryLook(farther.getDistance()));
            }
        }
        return result;
    }

/*    public boolean hasPriorityOver(
            Item rightItem) {

        if (this.alternative.getPriorityLevel() != rightItem.alternative
                .getPriorityLevel()) {
            return this.alternative.hasPriorityOver(rightItem.alternative);
        }

        if (this.itemType == ItemType.END) {
            return this.alternative.isLeftAssociative();
        }

        return this.alternative.isRightAssociative();
    }
*/
}


text:
package org.apache.jena.sparql.exec.http;

import static org.apache.jena.fuseki.test.HttpTest.expect404;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.io.StringReader;

import org.apache.jena.http.HttpOp;
import org.apache.jena.riot.Lang;
import org.apache.jena.riot.RDFDataMgr;
import org.apache.jena.sparql.core.DatasetGraph;
import org.apache.jena.sparql.core.DatasetGraphFactory;
import org.apache.jena.sparql.util.IsoMatcher;
import org.apache.jena.test.conn.EnvTest;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestDSP {

    static String DIR = "testing/RDFLink/";

    private static EnvTest env;
    @BeforeClass public static void beforeClass() {
        env = EnvTest.create("/ds");
    }

    @Before public void before() {
        env.clear();
    }

    @AfterClass public static void afterClass() {
        EnvTest.stop(env);
    }

    private String url(String path) { return env.datasetPath(path); }

    // Test DSP against the dataset itself.
    static String dspServiceURL()   { return env.datasetPath("/"); }

    static DatasetGraph dataset = makeDatasetGraph();
    static DatasetGraph makeDatasetGraph() {
        DatasetGraph dataset = DatasetGraphFactory.createTxnMem();
        RDFDataMgr.read(dataset, new StringReader("PREFIX : <http://example/> :s :p :o . :g { :sg :pg :og }"), null, Lang.TRIG);
        return dataset;
    }

    // ----------------------------------------

    @Test public void dsp_put_get_01() {
        DSP.service(dspServiceURL()).PUT(dataset);
        DatasetGraph dsg = DSP.service(dspServiceURL()).GET();
        assertNotNull(dsg);
        assertTrue(IsoMatcher.isomorphic(dataset, dsg));
    }

    @Test public void dsp_post_get_02() {
        DSP.service(dspServiceURL()).POST(dataset);
        DatasetGraph dsg = DSP.service(dspServiceURL()).GET();
        assertNotNull(dsg);
        assertTrue(IsoMatcher.isomorphic(dataset, dsg));
    }

    @Test public void dspHead_dataset_1() {
        // Base dspServiceURL(), default content type => N-Quads (dump format)
        String h = HttpOp.httpHead(dspServiceURL(), null);
        assertNotNull(h);
        assertEquals(Lang.NQUADS.getHeaderString(), h);
    }

    @Test public void dspHead_dataset_2() {
        String ct = Lang.TRIG.getHeaderString();
        String h = HttpOp.httpHead(dspServiceURL(), ct);
        assertNotNull(h);
        assertEquals(ct, h);
    }

    @Test public void dspHead_graph_1() {
        String target = dspServiceURL()+"?default";
        String h = HttpOp.httpHead(target, null);
        assertNotNull(h);
        // "Traditional default".
        assertEquals(Lang.RDFXML.getHeaderString(), h);
    }

    @Test public void dspHead_graph_2() {
        String target = dspServiceURL()+"?default";
        String ct = Lang.TTL.getHeaderString();
        String h = HttpOp.httpHead(target, ct);
        assertNotNull(h);
        assertEquals(ct, h);
    }

    @Test
    public void dsp_clear_01() {
        // DELETE on the DSP endpoint would be the default graph.
        // DELETE on the dataset endpoint is not supported by Fuseki - this does "CLER ALL"
        DSP.service(env.datasetURL()).clear();
    }

    @Test
    public void dsp_clear_02() {
        DSP.service(dspServiceURL()).POST(dataset);
        DSP.service(env.datasetURL()).clear();
        DatasetGraph dsg = DSP.service(dspServiceURL()).GET();
        assertFalse(dsg.find().hasNext());
    }

    @Test public void dsp_put_delete_01() {
        DSP.service(dspServiceURL()).PUT(dataset);
        DSP.service(dspServiceURL()).clear();
        DatasetGraph dsg = DSP.service(dspServiceURL()).GET();
        assertTrue(dsg.isEmpty());
    }

    // 404

    @Test public void dsp_404_dataset() {
        expect404(
            ()->DSP.service(dspServiceURL()+"junk").GET()
        );
    }
}


text:
package codes.rusty.jagar.net.packets.out;

import codes.rusty.jagar.net.packets.PacketOut;
import codes.rusty.jagar.nodes.Node;
import com.google.common.io.LittleEndianDataOutputStream;
import java.io.IOException;

public class PacketOutUpdateClient extends PacketOut {

    private final Node node;

    public PacketOutUpdateClient(Node node) {
        this.node = node;
    }

    @Override
    protected void write(LittleEndianDataOutputStream output) throws IOException {
        output.writeFloat(node.getX());
        output.writeFloat(node.getY());
        output.writeFloat(node.getSize());
    }

}