text:
package com.seuksa.distributed.other.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.apache.xerces.impl.dv.util.Base64;

/**
 *
 * @author sok.pongsametrey
 *
 */
public class ZipHelper {

    public static void CreateZipFile(String path){

    }

    /**
     * This the compress xml file request and respone
     * @param filename
     * @param zipFileName
     */
    public static void doZip(String filename, String zipFileName) throws Exception {

        File f = new File(filename);
        FileInputStream fis = null;
        ZipOutputStream zipOutputStream = null;
        try {
            if (f.exists()) {
                int size = (int)f.length();
                byte[] buf = new byte[size];
                fis = new FileInputStream(f.getAbsolutePath());
                fis.read(buf, 0, buf.length);
                CRC32 crc = new CRC32();
                zipOutputStream = new ZipOutputStream(new FileOutputStream(zipFileName));
                zipOutputStream.setLevel(6);
                ZipEntry entry = new ZipEntry(f.getName());
                entry.setSize(buf.length);
                crc.reset();
                crc.update(buf);
                entry.setCrc(crc.getValue());
                zipOutputStream.putNextEntry(entry);
                zipOutputStream.write(buf, 0, buf.length);
                zipOutputStream.finish();
             } else {
                System.out.println(">> Input file :  " + f.getPath() + "/" + f.getName() + " Not exists .");
            }
        } catch (FileNotFoundException fNotFound) {
            throw new Exception(">> Error during compressing file ", fNotFound);
        } catch (IOException ioe) {
            throw new Exception(">> Error during compressing file ", ioe);
        } catch (Exception e) {
            throw new Exception(">> Error during compressing file ", e);
        }
            finally {
            try {
                if (zipOutputStream != null) {
                    zipOutputStream.close();
                }
                if (fis != null) {
                    fis.close();
                }

                boolean success = f.delete();
                if (!success){
                    System.out.println("File : " + f.getName() + " Deletion failed.");
                  }else{
                    System.out.println("File : " + f.getName() + " deleted. ");
                  }

            } catch (IOException e) {
               throw new Exception(">> Error during closing Zip output Stream / deleting file . ",e);
            }
        }
    }

    public static void doUnzip (String zipFilename) {
    	Enumeration entries;
    	ZipFile zipFile;
    	if(zipFilename == null) {
    	System.err.println("Usage: Unzip zipfile");
    	return;
    	}
    	try {
    	zipFile = new ZipFile(zipFilename);
    	entries = zipFile.entries();
    	while(entries.hasMoreElements()) {
    	ZipEntry entry = (ZipEntry)entries.nextElement();
    	if(entry.isDirectory()) {
    		// Assume directories are stored parents first then children.
    		System.err.println("Extracting directory: " + entry.getName());
    		// This is not robust, just for demonstration purposes.
    		(new File(entry.getName())).mkdir();
    		continue;
    	}
    	System.err.println("Extracting file: " + entry.getName());
    	copyInputStream(zipFile.getInputStream(entry),
    	new BufferedOutputStream(new FileOutputStream(entry.getName())));
    	}
    	zipFile.close();
    	} catch (IOException ioe) {
    	System.err.println("Unhandled exception:");
    	ioe.printStackTrace();
    	return;
    	}
    }

    /**
     *
     * @param in
     * @param out
     * @throws IOException
     */
	public static final void copyInputStream(InputStream in, OutputStream out)
			throws IOException {
		byte[] buffer = new byte[1024];
		int len;
		while ((len = in.read(buffer)) >= 0)
			out.write(buffer, 0, len);
		in.close();
		out.close();
	}

    /**
     * This the compress request and response to zip file
     * @param filename
     * @param zipFileName
     */
    public static void doStringToZip(String filename, String zipFileName,byte [] buf) throws Exception {
        ZipOutputStream zipOutputStream = null;
        try {
            CRC32 crc = new CRC32();
            zipOutputStream = new ZipOutputStream(new FileOutputStream(zipFileName));
            zipOutputStream.setLevel(6);
            ZipEntry entry = new ZipEntry(filename);
            entry.setSize(buf.length);
            crc.reset();
            crc.update(buf);
            entry.setCrc(crc.getValue());
            zipOutputStream.putNextEntry(entry);
            zipOutputStream.write(buf, 0, buf.length);
            zipOutputStream.finish();

        } catch (FileNotFoundException fNotFound) {
            throw new Exception(">> Error during compressing file ", fNotFound);
        } catch (IOException ioe) {
            throw new Exception(">> Error during compressing file ", ioe);
        } catch (Exception e) {
            throw new Exception(">> Error during compressing file ", e);
        } finally {
            try {
                if (zipOutputStream != null) {
                    zipOutputStream.close();
                }
            } catch (IOException e) {
                throw new Exception(
                        ">> Error during closing Zip output Stream / deleting file . ", e);
            }
        }
    }
    /**
     * Reads a file storing intermediate data into an array.
     *
     * @param file
     *            the file to be read
     * @return a file data
     */
    public static byte[] read2Array(String file) throws Exception {
        InputStream in = null;
        byte[] out = new byte[0];

        try {
            if (FileUtils.isExistFiles(file).booleanValue()) {

                in = new BufferedInputStream(new FileInputStream(file));

                // the length of a buffer can vary
                int bufLen = 20000 * 1024;
                byte[] buf = new byte[bufLen];
                byte[] tmp = null;
                int len = 0;

                while ((len = in.read(buf, 0, bufLen)) != -1) {
                    // extend array
                    tmp = new byte[out.length + len];

                    // copy data
                    System.arraycopy(out, 0, tmp, 0, out.length);
                    System.arraycopy(buf, 0, tmp, out.length, len);
                    out = tmp;
                    tmp = null;
                }
            }
        } catch (Exception e) {
            StringBuffer err = new StringBuffer(">> Error durring execute method read2Array ");
            System.out.println(err.toString());
            throw new Exception(err.toString(), e);
        } finally {
            // always close the stream
            if (in != null) {
                try {
                    in.close();
                } catch (Exception e) {
                    StringBuffer err = new StringBuffer(">> Error durring closing buffer stream ");
                    System.out.println(err.toString());
                    throw new Exception(err.toString(), e);
                }
            }
        }
        return out;
    }
    /**
     * This transform the input data after compressing to
     * Basse 64 character
     * @param zipFileName
     * @return
     */
    public static String transformedInputDataToBase64Character(String zipFileName) throws Exception{
        String strEncode = null;
        byte[] fileToByte = null;
        try {
            if (FileUtils.isExistFiles(zipFileName).booleanValue()) {
                fileToByte = ZipHelper.read2Array(zipFileName);
            } else {
                System.out.println("Zip file : " + zipFileName + " input not exits ");
            }

        } catch (Exception e1) {
            StringBuffer msg = new StringBuffer(">> Error durring execute method transformedInputDataToBase64Character.");
            System.out.println(msg.toString());
            throw new Exception(msg.toString(),e1);
        }
        strEncode = Base64.encode(fileToByte);
        return strEncode;
    }

    public static List<String> decode64CharacterAndUnzipFile (String base64String, String serverDir) throws Exception {

    	byte[] decodedByte = Base64.decode(base64String);
    	if (decodedByte == null
    			|| decodedByte.length == 0) {
    		throw new Exception("Base64 found no any byte");
    	}
//        ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zipPath + "/" + zipfilename)));
//        //now create the entry in zip file
//
//        ZipEntry entry = new ZipEntry(zipfilename);
//        entry.setSize(decodedByte.length);
//        zos.putNextEntry(entry);
//        zos.write(decodedByte);
//        zos.closeEntry();
//        zos.close();

        ZipInputStream zipStream = new ZipInputStream(new ByteArrayInputStream(decodedByte));
        ZipEntry entry = null;
        List<String> lstEntries = new LinkedList<String>();
        while ((entry = zipStream.getNextEntry()) != null) {
            String entryName = entry.getName();
            FileOutputStream out = new FileOutputStream(serverDir + "/" + entryName);
            byte[] buf = new byte[4096];
            int bytesRead = 0;
            while ((bytesRead = zipStream.read(buf)) != -1) {
                out.write(buf, 0, bytesRead);
            }
            out.close();
            zipStream.closeEntry();
            lstEntries.add(entryName);
        }
        zipStream.close();

        return lstEntries;
    }

}


text:
package org.terasology.input.binds.general;

import org.terasology.input.BindButtonEvent;
import org.terasology.input.ControllerId;
import org.terasology.input.DefaultBinding;
import org.terasology.input.InputType;
import org.terasology.input.Keyboard;
import org.terasology.input.RegisterBindButton;

/**
 */
@RegisterBindButton(id = "pause", description = "Ingame Menu", category = "general")
@DefaultBinding(type = InputType.KEY, id = Keyboard.KeyId.ESCAPE)
@DefaultBinding(type = InputType.CONTROLLER_BUTTON, id = ControllerId.SEVEN)  // Button 9 for PlayStation Controllers
public class PauseButton extends BindButtonEvent {
}

redpajama_set_name: RedPajamaGithub


text:
#import <GeoFeatures/GeoFeatures.h>
#import <XCTest/XCTest.h>

static NSDictionary * geoJSON1;
static NSDictionary * geoJSON2;
static NSDictionary * invalidGeoJSON;

//
// Static constructor
//
static __attribute__((constructor(101),used,visibility("internal"))) void staticConstructor (void) {
    geoJSON1       = @{@"type": @"LineString", @"coordinates": @[@[@(100.0), @(0.0)],@[@(101.0), @(1.0)]]};
    geoJSON2       = @{@"type": @"LineString", @"coordinates": @[@[@(102.0), @(0.0)],@[@(102.0), @(1.0)]]};
    invalidGeoJSON = @{@"type": @"LineString", @"coordinates": @{}};
}

@interface GFLineStringTests : XCTestCase
@end

@implementation GFLineStringTests

#pragma mark - Test init

    - (void)testInit_NoThrow {
        XCTAssertNoThrow([[GFLineString alloc] init]);
    }

    - (void)testInit_NotNil {
        XCTAssertNotNil([[GFLineString alloc] init]);
    }

    - (void) testInit {
        XCTAssertEqualObjects([[[GFLineString alloc] init] toWKTString], @"LINESTRING()");
    }

#pragma mark - Test initWithGeoJSONGeometry

    - (void) testInitWithGeoJSONGeometry_WithInvalidGeoJSON {
        XCTAssertThrowsSpecificNamed([[GFLineString alloc] initWithGeoJSONGeometry:  @{@"invalid": @{}}], NSException, NSInvalidArgumentException);
    }

#pragma mark - Test initWithWKT

    - (void) testInitWithWKT_WithInvalidWKT {
        XCTAssertThrows([[GFLineString alloc] initWithWKT: @"INVALID()"]);
    }

#pragma mark - Test copy

    - (void) testCopy {
        XCTAssertEqualObjects([[[[GFLineString alloc] initWithWKT: @"LINESTRING(100 0,101 1)"] copy] toWKTString], @"LINESTRING(100 0,101 1)");
    }

#pragma mark - Test toGeoJSONGeometry

    - (void) testToGeoJSONGeometry {
        XCTAssertEqualObjects([[[GFLineString alloc] initWithGeoJSONGeometry: geoJSON1] toGeoJSONGeometry], geoJSON1);
    }

#pragma mark - Test description

    - (void) testDescription_WithGeoJSON1 {
        XCTAssertEqualObjects([[[GFLineString alloc] initWithGeoJSONGeometry: geoJSON1] description], @"LINESTRING(100 0,101 1)");
    }

    - (void) testDescription_WithGeoJSON2 {
        XCTAssertEqualObjects([[[GFLineString alloc] initWithGeoJSONGeometry: geoJSON2] description], @"LINESTRING(102 0,102 1)");
    }

#pragma mark - Test mapOverlays

    - (void) testMapOverlays {

        NSArray * mapOverlays = [[[GFLineString alloc] initWithGeoJSONGeometry: geoJSON1] mkMapOverlays];

        XCTAssertNotNil (mapOverlays);
        XCTAssertTrue   ([mapOverlays count] == 1);

        XCTAssertTrue   ([[mapOverlays lastObject] isKindOfClass: [MKPolyline class]]);

        MKPolyline * polyline = (MKPolyline *) [mapOverlays lastObject];

        XCTAssertTrue   ([polyline pointCount] == 2);
    }

#pragma mark - Test count

    - (void) testCount_WithEmptyLineString {
        XCTAssertEqual([[[GFLineString alloc] initWithWKT: @"LINESTRING()"] count], 0);
    }

    - (void) testCount_With1ElementLineString {
        XCTAssertEqual([[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60)"] count], 1);
    }

    - (void) testCount_With2ElementLineString {
        XCTAssertEqual([[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"] count], 2);
    }

#pragma mark - Test pointAtIndex

    - (void) testPointAtIndex_With2ElementLineStringAndIndex0 {
        XCTAssertEqualObjects([[[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"] pointAtIndex: 0] toWKTString], @"POINT(40 60)");
    }

    - (void) testPointAtIndex_With2ElementLineStringAndIndex1  {
        XCTAssertEqualObjects([[[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"] pointAtIndex: 1] toWKTString], @"POINT(120 110)");
    }

    - (void) testPointAtIndex_With1ElementLineStringAndOutOfRangeIndex  {
        XCTAssertThrowsSpecificNamed(([[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60)"] pointAtIndex: 1]), NSException, NSRangeException);
    }

#pragma mark - Test firstPoint

    - (void) testFirstPoint_With2ElementLineString {
        XCTAssertEqualObjects([[[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"] firstPoint] toWKTString], @"POINT(40 60)");
    }

    - (void) testFirstPoint_WithEmptyLineString_NoThrow {
        XCTAssertNoThrow([[[GFLineString alloc] initWithWKT: @"LINESTRING()"] firstPoint]);
    }

    - (void) testFirstPoint_WithEmptyLineString {
        XCTAssertEqualObjects([[[GFLineString alloc] initWithWKT: @"LINESTRING()"] firstPoint], nil);
    }

#pragma mark - Test lastPoint

    - (void) testLastPoint_With2ElementLineString  {
        XCTAssertEqualObjects([[[[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"] lastPoint] toWKTString], @"POINT(120 110)");
    }

    - (void) testLastPoint_WithEmptyLineString_NoThrow  {
        XCTAssertNoThrow([[[GFLineString alloc] initWithWKT: @"LINESTRING()"] lastPoint]);
    }

    - (void) testLastPoint_WithEmptyLineString  {
        XCTAssertEqualObjects([[[GFLineString alloc] initWithWKT: @"LINESTRING()"] lastPoint], nil);
    }

#pragma mark - Test objectAtIndexSubscript

    - (void) testObjectAtIndexedSubscript_With2ElementLineStringAndIndex0_NoThrow {
        GFLineString * lineString = [[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"];

        XCTAssertNoThrow(lineString[0]);
    }

    - (void) testObjectAtIndexedSubscript_With2ElementLineStringAndIndex1_NoThrow {
        GFLineString * lineString = [[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"];

        XCTAssertNoThrow(lineString[1]);
    }

    - (void) testObjectAtIndexedSubscript_With2ElementLineStringAndIndex0 {
        GFLineString * lineString = [[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"];

        XCTAssertEqualObjects([lineString[0] toWKTString], @"POINT(40 60)");
    }

    - (void) testObjectAtIndexedSubscript_With2ElementLineStringAndIndex1 {
        GFLineString * lineString = [[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"];

        XCTAssertEqualObjects([lineString[1] toWKTString], @"POINT(120 110)");
    }

    - (void) testObjectAtIndexedSubscript_With2ElementLineStringAndOutOfRangeIndex {
        GFLineString * lineString = [[GFLineString alloc] initWithWKT: @"LINESTRING(40 60,120 110)"];

        XCTAssertThrowsSpecificNamed(lineString[2], NSException, NSRangeException);
    }

@end


text:
<?xml version="1.0" encoding="UTF-8"?>
<archetype-descriptor xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0 http://maven.apache.org/xsd/archetype-descriptor-1.0.0.xsd" name="vaadinspringmodel"
    xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <fileSets>
    <fileSet filtered="true" packaged="true" encoding="UTF-8">
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.java</include>
      </includes>
    </fileSet>
    <fileSet filtered="true" encoding="UTF-8">
      <directory>src/main/resources</directory>
      <includes>
        <include>**/*.xml</include>
        <include>**/*.properties</include>
      </includes>
    </fileSet>
    <fileSet filtered="true" encoding="UTF-8">
      <directory>src/main/webapp</directory>
      <includes>
        <include>**/*.xml</include>
      </includes>
    </fileSet>
    <fileSet encoding="UTF-8">
      <directory>src/main/webapp</directory>
      <includes>
        <include>**/*.cache</include>
        <include>**/*.css</include>
        <include>**/*.ico</include>
        <include>**/*.scss</include>
      </includes>
    </fileSet>
    <fileSet filtered="true" packaged="true" encoding="UTF-8">
      <directory>src/test/java</directory>
      <includes>
        <include>**/*.java</include>
      </includes>
    </fileSet>
    <fileSet filtered="true" encoding="UTF-8">
      <directory>src/test/resources</directory>
      <includes>
        <include>**/*.properties</include>
      </includes>
    </fileSet>
    <fileSet filtered="true" encoding="UTF-8">
      <directory></directory>
      <includes>
        <include>.gitignore</include>
        <include>README.md</include>
      </includes>
    </fileSet>
    <fileSet encoding="UTF-8">
      <directory></directory>
      <includes>
        <include>mvnw.cmd</include>
        <include>mvnw</include>
      </includes>
    </fileSet>
  </fileSets>
</archetype-descriptor>


text:
<?xml version="1.0"?>

<config>
    <modules>
        <Magegiant_Community>
            <version>0.1.0</version>
        </Magegiant_Community>
    </modules>
    <admin>
        <routers>
            <communityadmin>
                <use>admin</use>
                <args>
                    <module>Magegiant_Community</module>
                    <frontName>communityadmin</frontName>
                </args>
            </communityadmin>
        </routers>
    </admin>
    <adminhtml>
        <layout>
            <updates>
                <community>
                    <file>magegiant/community.xml</file>
                </community>
            </updates>
        </layout>
        <translate>
            <modules>
                <Magegiant_Community>
                    <files>
                        <default>Magegiant_Community.csv</default>
                    </files>
                </Magegiant_Community>
            </modules>
        </translate>
    </adminhtml>
    <global>
        <models>
            <community>
                <class>Magegiant_Community_Model</class>
                <resourceModel>community_mysql4</resourceModel>
            </community>
            <community_mysql4>
                <class>Magegiant_Community_Model_Mysql4</class>
                <entities>
                    <community>

magegiant_community

                    </community>
                </entities>
            </community_mysql4>
        </models>
        <resources>
            <magegiant_community_setup>
                <setup>
                    <module>Magegiant_Community</module>
                </setup>
                <connection>
                    <use>core_setup</use>
                </connection>
            </magegiant_community_setup>
            <community_write>
                <connection>
                    <use>core_write</use>
                </connection>
            </community_write>
            <community_read>
                <connection>
                    <use>core_read</use>
                </connection>
            </community_read>
        </resources>
        <blocks>
            <community>
                <class>Magegiant_Community_Block</class>
            </community>
        </blocks>
        <helpers>
            <community>
                <class>Magegiant_Community_Helper</class>
            </community>
        </helpers>

    </global>
</config>


text:
import os
import re
import sys

sys.path.append(os.path.dirname(os.path.dirname(__file__)))

import khr_util.format
import khr_util.registry
import khr_util.registry_cache

SCRIPTS_DIR			= os.path.dirname(__file__)
OPENGL_DIR			= os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "framework", "opengl"))
EGL_DIR				= os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "framework", "egl"))
OPENGL_INC_DIR		= os.path.join(OPENGL_DIR, "wrapper")

GL_SOURCE			= khr_util.registry_cache.RegistrySource(
						"https://raw.githubusercontent.com/KhronosGroup/OpenGL-Registry",
						"xml/gl.xml",
						"d8371b44919d61c02e60f446a4b5461fda910f71",
						"60815a7993699b136338a02f28c6a5157a31f0ba8a4f9633115ce1e56e972e4b")

EXTENSIONS			= [
	'GL_KHR_texture_compression_astc_ldr',
	'GL_KHR_blend_equation_advanced',
	'GL_KHR_blend_equation_advanced_coherent',
	'GL_KHR_debug',
	'GL_EXT_robustness',
	'GL_KHR_robustness',
	'GL_KHR_no_error',
	'GL_KHR_parallel_shader_compile',
	'GL_KHR_shader_subgroup',
	'GL_EXT_bgra',
	'GL_EXT_geometry_point_size',
	'GL_EXT_tessellation_shader',
	'GL_EXT_geometry_shader',
	'GL_EXT_texture_buffer',
	'GL_EXT_texture_filter_anisotropic',
	'GL_EXT_texture_cube_map_array',
	'GL_EXT_texture_snorm',
	'GL_EXT_primitive_bounding_box',
	'GL_EXT_texture_compression_s3tc',
	'GL_EXT_texture_type_2_10_10_10_REV',
	'GL_EXT_clip_control',
	'GL_EXT_copy_image',
	'GL_EXT_depth_bounds_test',
	'GL_EXT_direct_state_access',
	'GL_EXT_draw_buffers_indexed',
	'GL_EXT_draw_elements_base_vertex',
	'GL_EXT_direct_state_access',
	'GL_EXT_read_format_bgra',
	'GL_EXT_texture_storage',
	'GL_EXT_texture_sRGB_decode',
	'GL_EXT_texture_border_clamp',
	'GL_EXT_texture_sRGB_R8',
	'GL_EXT_texture_sRGB_RG8',
	'GL_EXT_multisampled_render_to_texture',
	'GL_EXT_debug_marker',
	'GL_EXT_polygon_offset_clamp',
	'GL_EXT_fragment_shading_rate',
	'GL_IMG_texture_compression_pvrtc',
	'GL_OES_EGL_image',
	'GL_OES_EGL_image_external',
	'GL_OES_compressed_ETC1_RGB8_texture',
	'GL_OES_compressed_paletted_texture',
	'GL_OES_required_internalformat',
	'GL_OES_packed_depth_stencil',
	'GL_OES_texture_3D',
	'GL_OES_texture_half_float',
	'GL_OES_texture_storage_multisample_2d_array',
	'GL_OES_sample_shading',
	'GL_OES_standard_derivatives',
	'GL_OES_stencil1',
	'GL_OES_stencil4',
	'GL_OES_surfaceless_context',
	'GL_OES_mapbuffer',
	'GL_OES_vertex_array_object',
	'GL_OES_viewport_array',
	'GL_ARB_clip_control',
	'GL_ARB_buffer_storage',
	'GL_ARB_compute_shader',
	'GL_ARB_draw_indirect',
	'GL_ARB_draw_instanced',
	'GL_ARB_draw_elements_base_vertex',
	'GL_ARB_direct_state_access',
	'GL_ARB_get_program_binary',
	'GL_ARB_gl_spirv',
	'GL_ARB_indirect_parameters',
	'GL_ARB_internalformat_query',
	'GL_ARB_instanced_arrays',
	'GL_ARB_multi_draw_indirect',
	'GL_ARB_parallel_shader_compile',
	'GL_ARB_program_interface_query',
	'GL_ARB_separate_shader_objects',
	'GL_ARB_shader_ballot',
	'GL_ARB_shader_image_load_store',
	'GL_ARB_shader_viewport_layer_array',
	'GL_ARB_sparse_buffer',
	'GL_ARB_sparse_texture',
	'GL_ARB_spirv_extensions',
	'GL_ARB_tessellation_shader',
	'GL_ARB_texture_barrier',
	'GL_ARB_texture_filter_minmax',
	'GL_ARB_texture_gather',
	'GL_ARB_texture_storage',
	'GL_ARB_texture_storage_multisample',
	'GL_ARB_texture_multisample',
	'GL_ARB_texture_view',
	'GL_ARB_transform_feedback2',
	'GL_ARB_transform_feedback3',
	'GL_ARB_transform_feedback_instanced',
	'GL_ARB_transform_feedback_overflow_query',
	'GL_ARB_vertex_array_bgra',
	'GL_ARB_vertex_attrib_64bit',
	'GL_ARB_vertex_attrib_binding',
	'GL_NV_deep_texture3D',
	'GL_NV_gpu_multicast',
	'GL_NV_internalformat_sample_query',
	'GL_NV_shader_subgroup_partitioned',
	'GL_NVX_cross_process_interop',
	'GL_OES_draw_elements_base_vertex',
	'GL_OVR_multiview',
	'GL_OVR_multiview_multisampled_render_to_texture',
]

ALIASING_EXCEPTIONS = [
	# registry insists that this aliases glRenderbufferStorageMultisample,
	# and from a desktop GL / GLX perspective it *must*, but for ES they are
	# unfortunately separate functions with different semantics.
	'glRenderbufferStorageMultisampleEXT',
]

def getGLRegistry ():
	return khr_util.registry_cache.getRegistry(GL_SOURCE)

def getHybridInterface (stripAliasedExtCommands = True):
	# This is a bit awkward, since we have to create a strange hybrid
	# interface that includes both GL and ES features and extensions.
	registry = getGLRegistry()
	glFeatures = registry.getFeatures('gl')
	esFeatures = registry.getFeatures('gles2')
	spec = khr_util.registry.InterfaceSpec()

	for feature in registry.getFeatures('gl'):
		spec.addFeature(feature, 'gl', 'core')

	for feature in registry.getFeatures('gles2'):
		spec.addFeature(feature, 'gles2')

	for extName in EXTENSIONS:
		extension = registry.extensions[extName]
		# Add all extensions using the ES2 api, but force even non-ES2
		# extensions to be included.
		spec.addExtension(extension, 'gles2', 'core', force=True)

	iface = khr_util.registry.createInterface(registry, spec, 'gles2')

	if stripAliasedExtCommands:
		# Remove redundant extension commands that are already provided by core.
		strippedCmds = []

		for command in iface.commands:
			if command.alias == None or command.name in ALIASING_EXCEPTIONS:
				strippedCmds.append(command)

		iface.commands = strippedCmds

	return iface

def versionCheck(version):
	if type(version) is bool:
		if version == False:
			return True
	if type(version) is str:
		return version < "3.2"
	raise "Version check failed"

def getInterface (registry, api, version=None, profile=None, **kwargs):
	spec = khr_util.registry.spec(registry, api, version, profile, **kwargs)
	if api == 'gl' and profile == 'core' and versionCheck(version):
		gl32 = registry.features['GL_VERSION_3_2']
		for eRemove in gl32.xpath('remove'):
			spec.addComponent(eRemove)
	return khr_util.registry.createInterface(registry, spec, api)

def getVersionToken (api, version):
	prefixes = { 'gles2': "ES", 'gl': "GL" }
	return prefixes[api] + version.replace(".", "")

def genCommandList(iface, renderCommand, directory, filename, align=False):
	lines = map(renderCommand, iface.commands)
	lines = filter(lambda l: l != None, lines)
	if align:
		lines = indentLines(lines)
	writeInlFile(os.path.join(directory, filename), lines)

def genCommandLists(registry, renderCommand, check, directory, filePattern, align=False):
	for eFeature in registry.features:
		api			= eFeature.get('api')
		version		= eFeature.get('number')
		profile		= check(api, version)
		if profile is True:
			profile = None
		elif profile is False:
			continue
		iface		= getInterface(registry, api, version=version, profile=profile)
		filename	= filePattern % getVersionToken(api, version)
		genCommandList(iface, renderCommand, directory, filename, align)

def getFunctionTypeName (funcName):
	return "%sFunc" % funcName

def getFunctionMemberName (funcName):
	assert funcName[:2] == "gl"
	if funcName[:5] == "glEGL":
		# Otherwise we end up with gl.eGLImage...
		return "egl%s" % funcName[5:]
	else:
		return "%c%s" % (funcName[2].lower(), funcName[3:])

INL_HEADER = khr_util.format.genInlHeader("Khronos GL API description (gl.xml)", GL_SOURCE.getRevision())

def writeInlFile (filename, source):
	khr_util.format.writeInlFile(filename, INL_HEADER, source)

# Aliases from khr_util.common
indentLines			= khr_util.format.indentLines
normalizeConstant	= khr_util.format.normalizeConstant
commandParams		= khr_util.format.commandParams
commandArgs			= khr_util.format.commandArgs


text:
`PackedStruct` is a way to define packing strings (see [`Array#pack`](http://ruby-doc.org/core-2.0/Array.html#method-i-pack)).
It was created after @charliesome suggested [a format](https://gist.github.com/medcat/6dda0554f62e4f77253a) for defining these strings, but never finished it.

The basic way of defining a packed struct is such:

```Ruby
class RconPacket
  include PackedStruct
  struct_layout :packet do
    little_endian signed size[32] # defaults to a number of size 32.
                                  # also the same as: `little_endian signed long size`
    little_endian signed id[32]
    little_endian signed type[32]
    string body[size]
    null
  end
end
```

This can be accessed as:

```Ruby
RconPacket.structs[:packet].pack(size: 11, id: 1, type: 0, body: "hello world")
# => "\v\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00hello world\x00"
```

You can also unpack strings.

```Ruby
RconPacket.structs[:packet].unpack("\v\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00hello world\x00")
# => {:size => 11, :id => 1, :type => 0, :body => "hello world"}
```

From sockets, too.  Anything that responds to `#read`.

```Ruby
file = File.open("/path/to/some/file", "r")

RconPacket.structs[:packet].unpack_from_socket(file)
# => ...
```

[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/redjazz96/packed_struct/trend.png)](https://bitdeli.com/free "Bitdeli Badge")


text:
This is an implementation of the [Bank OCR Kata](http://codingdojo.org/kata/BankOCR/). It only addresses user story #1.

## Getting Started

This assumes you have a Javascript development with
[Node.js](https://nodejs.org/en/) (v6.11.0) and
[npm](https://www.npmjs.com/) (v3.10.10).

1. ``npm install``
2. ``npm link``

You can now run ``bankocr data/accounts.txt`` to see the program in action. Alternatively you can also run ``npm run app data/accounts.txt``.

## Tests

``npm test``

Nothing fancy, just a handful of Jest tests.


text:
#ifndef __MACH_PXA27x_H
#define __MACH_PXA27x_H

#include <mach/hardware.h>
#include <mach/pxa2xx-regs.h>
#include <mach/mfp-pxa27x.h>

#define ARB_CNTRL	__REG(0x48000048)  /* Arbiter Control Register */

#define ARB_DMA_SLV_PARK	(1<<31)	   /* Be parked with DMA slave when idle */
#define ARB_CI_PARK		(1<<30)	   /* Be parked with Camera Interface when idle */
#define ARB_EX_MEM_PARK 	(1<<29)	   /* Be parked with external MEMC when idle */
#define ARB_INT_MEM_PARK	(1<<28)	   /* Be parked with internal MEMC when idle */
#define ARB_USB_PARK		(1<<27)	   /* Be parked with USB when idle */
#define ARB_LCD_PARK		(1<<26)	   /* Be parked with LCD when idle */
#define ARB_DMA_PARK		(1<<25)	   /* Be parked with DMA when idle */
#define ARB_CORE_PARK		(1<<24)	   /* Be parked with core when idle */
#define ARB_LOCK_FLAG		(1<<23)	   /* Only Locking masters gain access to the bus */

extern int __init pxa27x_set_pwrmode(unsigned int mode);

#endif /* __MACH_PXA27x_H */


text:
/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.camunda.bpm.engine.impl.cmmn.handler;

import java.util.HashMap;
import org.camunda.bpm.engine.impl.ProcessEngineLogger;
import org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity;
import org.camunda.bpm.engine.impl.cmmn.model.CmmnActivity;
import org.camunda.bpm.engine.impl.cmmn.model.CmmnCaseDefinition;
import org.camunda.bpm.engine.impl.cmmn.transformer.CmmnTransformerLogger;
import org.camunda.bpm.engine.impl.task.TaskDefinition;
import org.camunda.bpm.engine.impl.util.ParseUtil;
import org.camunda.bpm.engine.repository.Deployment;
import org.camunda.bpm.model.cmmn.CmmnModelInstance;
import org.camunda.bpm.model.cmmn.instance.Case;
import org.camunda.bpm.model.cmmn.instance.CmmnElement;
import org.camunda.bpm.model.cmmn.instance.Definitions;

/**
 * @author Roman Smirnov
 *
 */
public class CaseHandler extends CmmnElementHandler<Case, CmmnCaseDefinition> {

  protected static final CmmnTransformerLogger LOG = ProcessEngineLogger.CMMN_TRANSFORMER_LOGGER;

  public CmmnCaseDefinition handleElement(Case element, CmmnHandlerContext context) {
    CaseDefinitionEntity definition = createActivity(element, context);

    initializeActivity(element, definition, context);

    return definition;
  }

  protected void initializeActivity(Case element, CmmnActivity activity, CmmnHandlerContext context) {
    CaseDefinitionEntity definition = (CaseDefinitionEntity) activity;

    Deployment deployment = context.getDeployment();

    definition.setKey(element.getId());
    definition.setName(element.getName());
    definition.setDeploymentId(deployment.getId());
    definition.setTaskDefinitions(new HashMap<String, TaskDefinition>());
    definition.setHistoryTimeToLive(ParseUtil.parseHistoryTimeToLive(element.getCamundaHistoryTimeToLiveString()));
    CmmnModelInstance model = context.getModel();

    Definitions definitions = model.getDefinitions();
    String category = definitions.getTargetNamespace();
    definition.setCategory(category);
  }

  protected CaseDefinitionEntity createActivity(CmmnElement element, CmmnHandlerContext context) {
    CaseDefinitionEntity definition = new CaseDefinitionEntity();

    definition.setCmmnElement(element);

    return definition;
  }

}


text:
/*global define*/
define([
    'controllers/base/controller',
    'views/404-view'
], function (Controller, NotFoundView) {
    'use strict';

    var HomeController = Controller.extend({

        show: function (params) {

            this.view = new NotFoundView({
                region: 'main'
            });
        }
    });

    return HomeController;
});


text:
/* SortieManager.js
KC3改 Sortie Manager

Xxxxxxx
*/
(function(){
	"use strict";

	window.KC3SortieManager = {
		onSortie: 0,
		fleetSent: 1,
		map_world: 0,
		map_num: 0,
		nextNodeCount: 0,
		nodes: [],
		boss: {},
		onBossAvailable: function(){},
		onEnemiesAvailable: function(node){},

		startSortie :function(world, mapnum, fleetNum, stime){
			// If still on sortie, end previous one
			if(this.onSortie > 0){ this.endSortie(); }

			this.fleetSent = fleetNum;
			this.map_world = world;
			this.map_num = mapnum;
			this.nextNodeCount = 0;
			this.nodes = [];
			this.boss = {
				node: -1,
				comp: -1,
				info: false,
				formation: -1,
				ships: [ -1, -1, -1, -1, -1, -1 ]
			};

			// Save on database and remember current sortieId
			var self = this;
			KC3Database.Sortie({
				world: world,
				mapnum: mapnum,
				fleetnum: parseInt(fleetNum, 10),
				combined: PlayerManager.combinedFleet,
				fleet1: PlayerManager.fleets[0].sortieJson(),
				fleet2: PlayerManager.fleets[1].sortieJson(),
				fleet3: PlayerManager.fleets[2].sortieJson(),
				fleet4: PlayerManager.fleets[3].sortieJson(),
				support1: this.getSupportingFleet(false),
				support2: this.getSupportingFleet(true),
				time: stime
			}, function(id){
				self.onSortie = id;
			});
		},

		getSupportingFleet :function(bossSupport){
			var expedNumbers;
			if(bossSupport){
				expedNumbers = [34,110,118,126,150];
				return this.checkIfFleetIsSupporting(expedNumbers, 1)
					|| this.checkIfFleetIsSupporting(expedNumbers, 2)
					|| this.checkIfFleetIsSupporting(expedNumbers, 3);
			}else{
				expedNumbers = [33,109,117,125,149];
				return this.checkIfFleetIsSupporting(expedNumbers, 1)
					|| this.checkIfFleetIsSupporting(expedNumbers, 2)
					|| this.checkIfFleetIsSupporting(expedNumbers, 3);
			}
		},

		checkIfFleetIsSupporting :function(expedNumbers, fleetNumber){
			if(PlayerManager.fleets[fleetNumber].active){
				var fleetExpedition = PlayerManager.fleets[fleetNumber].mission[1];
				return (expedNumbers.indexOf(fleetExpedition)>-1)?fleetNumber:0;
			}
			return 0;
		},

		setBoss :function( cellno, comp ){
			this.boss.node = cellno;
			this.boss.comp = comp;

			var self = this;
			// Retrieve boss info from somewhere
			setTimeout(function(){
				console.log("");
				self.boss.formation = -1;
				// self.boss.ships = [ -1, -1, -1, -1, -1, -1 ];
				self.boss.ships = [ 501,502,503,504,505,506 ];
				self.onBossAvailable(self);
			}, 1)
		},

		currentNode :function(){
			return this.nodes[ this.nodes.length-1 ];
		},

		advanceNode :function( nodeData, UTCTime ){
			var thisNode;

			//  Battle Node
			if(typeof nodeData.api_enemy != "undefined") {
				thisNode = (new KC3Node( this.onSortie, nodeData.api_no, UTCTime )).defineAsBattle(nodeData);
			// Resource Node
			}else if (typeof nodeData.api_itemget != "undefined") {
				thisNode = (new KC3Node( this.onSortie, nodeData.api_no, UTCTime )).defineAsResource(nodeData);
			// Bounty Node
			} else if (typeof nodeData.api_itemget_eo_comment != "undefined") {
				thisNode = (new KC3Node( this.onSortie, nodeData.api_no, UTCTime )).defineAsBounty(nodeData);
			// Maelstrom Node
			} else if (typeof nodeData.api_happening != "undefined") {
				thisNode = (new KC3Node( this.onSortie, nodeData.api_no, UTCTime )).defineAsMaelstrom(nodeData);
			// Empty Node
			}else{
				thisNode = (new KC3Node( this.onSortie, nodeData.api_no, UTCTime )).defineAsDud(nodeData);
			}

			this.nodes.push(thisNode);
		},

		engageBattle :function( battleData, stime ){
			if(this.currentNode().type != "battle"){ console.error("Wrong node handling"); return false; }
			this.currentNode().engage( battleData );
		},

		engageNight :function( nightData ){
			if(this.currentNode().type != "battle"){ console.error("Wrong node handling"); return false; }
			 this.currentNode().night( nightData );
		},

		resultScreen :function( resultData ){
			if(this.currentNode().type != "battle"){ console.error("Wrong node handling"); return false; }
			this.currentNode().results( resultData );
		},

		endSortie :function(){
			this.onSortie = 0;
			this.fleetSent = 1;
			this.map_world = 0;
			this.map_num = 0;
			this.nextNodeCount = 0;
			this.nodes = [];
			this.boss = {
				node: -1,
				comp: -1,
				info: false,
				formation: -1,
				ships: [ -1, -1, -1, -1, -1, -1 ]
			};
		}
	};

})();


text:
UrlShortner::Application.config.session_store :cookie_store, :key => '_url_shortner_session'

# Use the database for sessions instead of the cookie-based default,
# which shouldn't be used to store highly confidential information
# (create the session table with "rails generate session_migration")
# UrlShortner::Application.config.session_store :active_record_store


text:
require 'rails_helper'

module Pubsubhubbub
  RSpec.describe DeliverPayloadJob, type: :job do
    pending "add some examples to (or delete) #{__FILE__}"
  end
end


text:
Typography

This guideline explains the typography suite designed to meet the highest standards of usability and accessibility, while setting a consistent visual voice of credibility, warmth, and ease-of-use across Australian government digital platforms.

Overview

Australian government websites have common typographic needs: clear and consistent headings, highly legible body paragraphs, clear labels, and easy-to-use input fields. We recommend a font system that uses two open-source font families: Open Sans Pro and Merriweather, both of which are designed for legibility and can beautifully adapt to a variety of visual styles.

Typefaces

Open Sans

Open Sans is an open-source sans serif typeface created for legibility in UI design. With a variety of weights that read easily at all sizes, Open Sans provides clear headers as well as highly-readable body text.
Open Sans is a humanist sans serif typeface designed by Steve Matteson, Type Director of Ascender Corp. This version contains the complete 897 character set, which includes the standard ISO Latin 1, Latin CE, Greek and Cyrillic character sets. Open Sans was designed with an upright stress, open forms and a neutral, yet friendly appearance. It was optimized for print, web, and mobile interfaces, and has excellent legibility characteristics in its letterforms.

  Aa
  Aa
  Aa

Open sans bold

ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890(!@#s%g.,?:;)

Open sans regular

ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890(!@#s%g.,?:;)

Open sans light

ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890(!@#s%g.,?:;)

Type sizes

We've developed our type sizes to be suitable for average screen densities and reading comfort under typical conditions.

We size our type across the following four breakpoint groups to suit a range of devices:

Ex small devices - less than 420 pixels (typically smart phones)

Small devices - 768 pixels (typically tablet devices).

Medium devices - 1000 pixels and above (typically desktop or laptop screens).

Large devices - 1200 pixels and above (typically large desktop or laptop screens).

The sizes shown below correspond to size and line-height (size/line-height) and are in pixels, based on a baseline of 72 pixels per inch (ppi). We recommend you set font sizes using relative units to allow for the changing nature of the user's browser. This creates uniformity across different screen sizes and capabilities.

      Ex small devices
Phones (<420px)
      Small devices
Tablets (>768px)
      Medium devices
Desktops (1000px)
      Large devices
Desktops (>1200px)

      Display type 1
      28/32
      28/32
      28/32
      28/32

      Display type 2
      20/24
      20/24
      20/24
      20/24

      Display heading
      20/24
      20/24
      20/24
      20/24

      h1 Article main title
      18/22
      18/22
      18/22
      18/22

      h2 section heading
      15/20
      15/20
      15/20
      15/20

      h3 sub section heading
      15/18
      15/18
      15/18
      15/18

      h4 sub section heading
      14/16
      14/16
      14/16
      14/16

      Body Copy
      15/20
      15/20
      15/20
      15/20

Type sizes example

Display type 1 58px

Display type 2 58px

Display heading 36px

h1 Article main title 36px

h2 section heading 30px

h3 sub section heading 24px

h4 sub section heading 18px

Body copy (Medium devices)

Intro paragraph. It has a fixed size,and fixed line height and a maximum width. rumquis dis debita ipicimo sapienis doloreh enditiosani cullacepuda solo expliaest fugit, consecae. Um eictusa nihillant omnia 20px.

Body desktop. It has a fixed size,and fixed line height and a maximum width.Istrum conseque rae pos doluptatur, autemo te rerum volum eum  Truffaut. Vegan Echo Park iPhone: 16px

Line height and spacing

Pairing examples (Medium devices)

To achieve proper readability and appropriate pacing, line heights have been determined based on each style's individual size and weight. Line wrapping only applies to Body, Subhead, Headline, and the smaller Display styles. All other styles should exist as single lines.

Type setting

Examples (Medium devices)

To achieve proper readability and appropriate pacing, line heights have been determined based on each style's individual size and weight. Line wrapping only applies to Body, Subhead, Headline, and the smaller Display styles. All other styles should exist as single lines.

Quote An editorial pullout quote from the main body quos letterpress, plaid fanny pack cavore chambray banjo Truffaut. Vegan Echo Park iPhone, Brooklyn normcore voluptatus 22px."

Bullet desktop. It has a fixed size,and fixed line height and a maximum width. Istrum conseque rae pos doluptatur, autemo 16px.

eum faccupti dolecabor asim quos voluptatus is moluptae non enis velitate. Literally occupy est letterpress, plaid fanny pack locavore.

Bullet mobile. It has a fixed size,and fixed line height and a maximum width of 67-75 characters 16px.

Istrum conseque rae pos doluptatur, autemo.

eum faccupti dolecabor asim quos voluptatus is moluptae.


text:
$: << File.expand_path('../lib', File.dirname(__FILE__))
require 'active_record_models'

require 'database_cleaner'
DatabaseCleaner.strategy = :transaction

RSpec.configure do |config|
  config.mock_with :rspec
  config.before do
    DatabaseCleaner.start
  end
  config.after do
    DatabaseCleaner.clean
  end
end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>Target (Bouncy Castle Library 1.54 API Specification)</title>
<meta name="date" content="2015-12-29">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Tree

Deprecated

Index

Help

Bouncy Castle Cryptography Library 1.54

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.bouncycastle.asn1.x509

Class Target

java.lang.Object

org.bouncycastle.asn1.ASN1Object

org.bouncycastle.asn1.x509.Target

All Implemented Interfaces:

ASN1Choice, ASN1Encodable, Encodable

public class Target
extends ASN1Object
implements ASN1Choice

Target structure used in target information extension for attribute
 certificates from RFC 3281.

     Target  ::= CHOICE {
       targetName          [0] GeneralName,
       targetGroup         [1] GeneralName,
       targetCert          [2] TargetCert
     }

 The targetCert field is currently not supported and must not be used
 according to RFC 3281.

Field Summary

Fields

Modifier and Type
Field and Description

static int
targetGroup

static int
targetName

Constructor Summary

Constructors

Constructor and Description

Target(int type,
      GeneralName name)

Constructor from given details.

Method Summary

Methods

Modifier and Type
Method and Description

static Target
getInstance(java.lang.Object obj)

Creates an instance of a Target from the given object.

GeneralName
getTargetGroup()

GeneralName
getTargetName()

ASN1Primitive
toASN1Primitive()

Produce an object suitable for an ASN1OutputStream.

Methods inherited from class org.bouncycastle.asn1.ASN1Object

equals, getEncoded, getEncoded, hasEncodedTagValue, hashCode, toASN1Object

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Field Detail

targetName

public static final int targetName

See Also:

Constant Field Values

targetGroup

public static final int targetGroup

See Also:

Constant Field Values

Constructor Detail

Target

public Target(int type,
      GeneralName name)

Constructor from given details.

 Exactly one of the parameters must be not null.

Parameters:

type - the choice type to apply to the name.

name - the general name.

Throws:

java.lang.IllegalArgumentException - if type is invalid.

Method Detail

getInstance

public static Target getInstance(java.lang.Object obj)

Creates an instance of a Target from the given object.

 obj can be a Target or a ASN1TaggedObject

Parameters:

obj - The object.

Returns:

A Target instance.

Throws:

java.lang.IllegalArgumentException - if the given object cannot be
             interpreted as Target.

getTargetGroup

public GeneralName getTargetGroup()

Returns:

Returns the targetGroup.

getTargetName

public GeneralName getTargetName()

Returns:

Returns the targetName.

toASN1Primitive

public ASN1Primitive toASN1Primitive()

Produce an object suitable for an ASN1OutputStream.

 Returns:

     Target  ::= CHOICE {
       targetName          [0] GeneralName,
       targetGroup         [1] GeneralName,
       targetCert          [2] TargetCert
     }

Specified by:

toASN1Primitive in interface ASN1Encodable

Specified by:

toASN1Primitive in class ASN1Object

Returns:

a ASN1Primitive

Overview

Package

Class

Tree

Deprecated

Index

Help

Bouncy Castle Cryptography Library 1.54

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
// XLA-specific reduction Ops.

#include "tensorflow/compiler/tf2xla/kernels/reduction_ops.h"
#include "tensorflow/compiler/tf2xla/type_util.h"
#include "tensorflow/compiler/tf2xla/xla_helpers.h"
#include "tensorflow/compiler/tf2xla/xla_op_registry.h"
#include "tensorflow/compiler/xla/client/lib/constants.h"
#include "tensorflow/compiler/xla/client/xla_builder.h"
#include "tensorflow/compiler/xla/literal.h"
#include "tensorflow/core/framework/kernel_def_builder.h"

namespace tensorflow {
namespace {

class SumOp : public XlaReductionOp {
 public:
  explicit SumOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx,
                       XlaHelpers::SumAccumulationType(ctx->input_type(0))) {}
  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::Zero(builder, xla_reduction_type_);
  }
  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Add(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("Sum").CompileTimeConstantInput("reduction_indices"),
                SumOp);

class ProdOp : public XlaReductionOp {
 public:
  explicit ProdOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx,
                       XlaHelpers::SumAccumulationType(ctx->input_type(0))) {}

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::One(builder, xla_reduction_type_);
  }

  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Mul(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("Prod").CompileTimeConstantInput("reduction_indices"),
                ProdOp);

class MinOp : public XlaReductionOp {
 public:
  explicit MinOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx, ctx->input_type(0)) {}

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::MaxValue(builder, xla_reduction_type_);
  }

  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Min(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("Min").CompileTimeConstantInput("reduction_indices"),
                MinOp);

class MaxOp : public XlaReductionOp {
 public:
  explicit MaxOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx, ctx->input_type(0)) {
    OP_REQUIRES_OK(ctx, PrimitiveTypeCheck(xla_reduction_type_));
  }

  static Status PrimitiveTypeCheck(xla::PrimitiveType xla_reduction_type) {
    if (xla_reduction_type == xla::C64 || xla_reduction_type == xla::C128 ||
        xla_reduction_type == xla::TUPLE ||
        xla_reduction_type == xla::OPAQUE_TYPE) {
      return errors::InvalidArgument(
          "Unsupported PrimitiveType in MaxOp: '",
          xla::PrimitiveType_Name(xla_reduction_type), "'");
    } else {
      return Status::OK();
    }
  }

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::MinValue(builder, xla_reduction_type_);
  }

  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Max(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("Max").CompileTimeConstantInput("reduction_indices"),
                MaxOp);

class MeanOp : public XlaReductionOp {
 public:
  explicit MeanOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx,
                       XlaHelpers::SumAccumulationType(ctx->input_type(0))) {}

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::Zero(builder, xla_reduction_type_);
  }
  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Add(scalar_lhs, scalar_rhs);
  }

  xla::XlaOp BuildFinalizer(
      xla::XlaBuilder* /*builder*/, const xla::XlaOp& input,
      const xla::XlaOp& reduce_output,
      const std::vector<int64_t>& dimensions_to_reduce) override {
    if (dimensions_to_reduce.empty()) {
      return reduce_output;
    }
    auto divisor = xla::GetDimensionSize(input, dimensions_to_reduce[0]);
    for (int i = 1; i < dimensions_to_reduce.size(); i++) {
      auto size = xla::GetDimensionSize(input, dimensions_to_reduce[i]);
      divisor = xla::Mul(divisor, size);
    }
    divisor = xla::ConvertElementType(divisor, xla_reduction_type_);
    return XlaHelpers::ConvertElementType(reduce_output / divisor,
                                          input_type(0));
  }
};

REGISTER_XLA_OP(Name("Mean").CompileTimeConstantInput("reduction_indices"),
                MeanOp);

class AllOp : public XlaReductionOp {
 public:
  explicit AllOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx, ctx->input_type(0)) {}

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::ConstantR0<bool>(builder, true);
  }

  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::And(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("All").CompileTimeConstantInput("reduction_indices"),
                AllOp);

class AnyOp : public XlaReductionOp {
 public:
  explicit AnyOp(OpKernelConstruction* ctx)
      : XlaReductionOp(ctx, ctx->input_type(0)) {}

  xla::XlaOp InitialValue(xla::XlaBuilder* builder) override {
    return xla::ConstantR0<bool>(builder, false);
  }

  void BuildReducer(xla::XlaBuilder* builder, const xla::XlaOp& scalar_lhs,
                    const xla::XlaOp& scalar_rhs) override {
    xla::Or(scalar_lhs, scalar_rhs);
  }
};

REGISTER_XLA_OP(Name("Any").CompileTimeConstantInput("reduction_indices"),
                AnyOp);

}  // namespace
}  // namespace tensorflow


text:
import copy
import random
from pathlib import Path
import tracemalloc
import gc
import sys
from contextlib import contextmanager
import json
from unittest import mock

import responses

from cumulusci.core.config import UniversalConfig
from cumulusci.core.config import BaseProjectConfig
from cumulusci.core.keychain import BaseProjectKeychain
from cumulusci.core.config import OrgConfig
from cumulusci.tasks.bulkdata.tests import utils as bulkdata_utils

def random_sha():
    hash = random.getrandbits(128)
    return "%032x" % hash

def create_project_config(
    repo_name="TestRepo",
    repo_owner="TestOwner",
    repo_commit=None,
    namespace=None,
):
    universal_config = UniversalConfig()
    project_config = DummyProjectConfig(
        universal_config=universal_config,
        repo_name=repo_name,
        repo_owner=repo_owner,
        repo_commit=repo_commit,
        config=copy.deepcopy(universal_config.config),
    )
    if namespace:
        project_config.config["project"]["package"]["namespace"] = namespace
    keychain = BaseProjectKeychain(project_config, None)
    project_config.set_keychain(keychain)
    return project_config

class DummyProjectConfig(BaseProjectConfig):
    def __init__(
        self, universal_config, repo_name, repo_owner, repo_commit=None, config=None
    ):
        repo_info = {
            "owner": repo_owner,
            "name": repo_name,
            "url": f"https://github.com/{repo_owner}/{repo_name}",
            "commit": repo_commit or random_sha(),
        }
        super(DummyProjectConfig, self).__init__(
            universal_config, config, repo_info=repo_info
        )

class DummyOrgConfig(OrgConfig):
    def __init__(self, config=None, name=None, keychain=None, global_org=False):
        if not name:
            name = "test"
        super(DummyOrgConfig, self).__init__(config, name, keychain, global_org)

    def refresh_oauth_token(self, keychain):
        pass

class DummyLogger(object):
    def __init__(self):
        self.out = []

    def log(self, msg, *args):
        self.out.append(msg % args)

    # Compatibility with various logging methods like info, warning, etc
    def __getattr__(self, name):
        return self.log

    def get_output(self):
        return "\n".join(self.out)

class DummyService(object):
    password = "password"

    def __init__(self, name):
        self.name = name

class DummyKeychain(object):
    def get_service(self, name):
        return DummyService(name)

    @property
    def global_config_dir(self):
        return Path.home() / "cumulusci"

    @property
    def cache_dir(self):
        return Path.home() / "project/.cci"

@contextmanager
def assert_max_memory_usage(max_usage):
    "Assert that a test does not exceed a certain memory threshold"
    tracemalloc.start()
    yield
    current, peak = tracemalloc.get_traced_memory()
    if peak > max_usage:
        big_objs(traced_only=True)
        assert peak < max_usage, ("Peak incremental memory usage was high:", peak)
    tracemalloc.stop()

def big_objs(traced_only=False):

    big_objs = (
        (sys.getsizeof(obj), obj)
        for obj in gc.get_objects()
        if sys.getsizeof(obj) > 20000
        and (tracemalloc.get_object_traceback(obj) if traced_only else True)
    )
    for size, obj in big_objs:
        print(type(obj), size, tracemalloc.get_object_traceback(obj))

class FakeSF:
    """Extremely simplistic mock of the Simple-Salesforce API

    Can be improved as needed over time.
    In particular, __getattr__ is not implemented yet.
    """

    fakes = {}

    def describe(self):
        return self._get_json("global_describe")

    @property
    def sf_version(self):
        return "47.0"

    def _get_json(self, fake_dataset):
        self.fakes[fake_dataset] = self.fakes.get("sobjname", None) or read_mock(
            fake_dataset
        )
        return self.fakes[fake_dataset]

def read_mock(name: str):
    base_path = Path(__file__).parent.parent / "tasks/bulkdata/tests"

    with (base_path / f"{name}.json").open("r") as f:
        return f.read()

def mock_describe_calls(domain="example.com"):
    def mock_sobject_describe(name: str):
        responses.add(
            method="GET",
            url=f"https://{domain}/services/data/v48.0/sobjects/{name}/describe",
            body=read_mock(name),
            status=200,
        )

    responses.add(
        method="GET",
        url=f"https://{domain}/services/data",
        body=json.dumps([{"version": "40.0"}, {"version": "48.0"}]),
        status=200,
    )
    responses.add(
        method="GET",
        url=f"https://{domain}/services/data",
        body=json.dumps([{"version": "40.0"}, {"version": "48.0"}]),
        status=200,
    )

    responses.add(
        method="GET",
        url=f"https://{domain}/services/data/v48.0/sobjects",
        body=read_mock("global_describe"),
        status=200,
    )

    for sobject in [
        "Account",
        "Contact",
        "Opportunity",
        "OpportunityContactRole",
        "Case",
    ]:
        mock_sobject_describe(sobject)

@contextmanager
def mock_salesforce_client(task, *, is_person_accounts_enabled=False):
    mock_describe_calls("test.salesforce.com")

    real_init = task._init_task
    salesforce_client = FakeSF()

    def _init_task():
        real_init()
        task.bulk = bulkdata_utils.FakeBulkAPI()
        task.sf = salesforce_client

    with mock.patch(
        "cumulusci.core.config.OrgConfig.is_person_accounts_enabled",
        lambda: is_person_accounts_enabled,
    ), mock.patch.object(task, "_init_task", _init_task):
        yield


text:
require 'test/unit'
require '../lib/historyList.rb'
class TestHistoryList < Test::Unit::TestCase
  def setup
    @sample = File.read("historyTestFile.Rconsole")
    test_init
  end
  def test_init
    assert_nothing_raised() { @list = HistoryList.new(@sample) }
    assert_not_nil(@list)
    assert_not_nil(@list.list)
    assert_not_nil(@list.last_line)
    assert_equal(@sample, @list.text + "> ")
  end
  def test_uniqueness
    assert_equal(3, @list.list.length)
    assert_equal(["second command","first command","third command"],@list.list)
  end
  def test_last_line
    assert_equal("> ",@list.last_line)
  end
  def test_add_line
    assert_equal(@sample + "hey", @list.add_line("> hey"))
  end
  def test_next_item
    assert_equal("first command", @list.next_item("second command"))
    assert_equal("first command", @list.next_item(">second command"))
    assert_equal("third command", @list.next_item("first command"))
    assert_equal("third command", @list.next_item("> first command"))
    assert_equal(nil, @list.next_item("third command"))
    assert_equal("second command", @list.next_item(" "))
    assert_equal("second command", @list.next_item("> "))
    assert_equal("second command", @list.next_item(""))
    assert_equal("second command", @list.next_item(nil))
  end
  def test_previous_item
    assert_equal("second command", @list.previous_item("first command"))
    assert_equal("second command", @list.previous_item(">first command"))
    assert_equal("first command", @list.previous_item("third command"))
    assert_equal("first command", @list.previous_item("> third command"))
    assert_equal(nil, @list.previous_item("second command"))
    assert_equal("third command", @list.previous_item(" "))
    assert_equal("third command", @list.previous_item("> "))
    assert_equal("third command", @list.previous_item(""))
    assert_equal("third command", @list.previous_item(nil))
  end
  def test_move_commands
    assert_equal(@sample + "second command", @list.move_down)
    assert_equal(@sample + "third command",@list.move_up)
    assert_equal(@sample,HistoryList.move_down(@list.move_up))
  end
end


text:
/*
    UFSCar Summer Tour
    ED - 2015/1
    UFSCar - São Carlos
*/
#ifndef PIECE_H
#define PIECE_H

#include <string>

namespace tour {
	/*
		Encapsula uma "Peça" do jogo,
		representada por um identificador inteiro
	*/
	class Piece {
	private:
	    std::string _path;
		std::string _name;
		int _frames;
	public:
	    Piece ();
		Piece (std::string path, std::string name, int frames);

        std::string getPath () const;
		std::string getName () const;
		int getFrames () const;

		bool operator ==(const Piece &b) const {
            return this->getPath() == b.getPath();
		}
	};
}

#endif


text:
package storage

import (
	"reflect"
	"testing"

	"facette.io/sliceutil"
	"facette.io/sqlstorage"
	"github.com/stretchr/testify/assert"
)

func testInterfaceToSlice(v interface{}) []interface{} {
	rv := reflect.ValueOf(v)
	if rv.Kind() == reflect.Ptr {
		rv = rv.Elem()
	}
	if rv.Kind() != reflect.Slice {
		return nil
	}

	result := []interface{}{}
	for i, n := 0, rv.Len(); i < n; i++ {
		result = append(result, rv.Index(i).Interface())
	}

	return result
}

func testNewItem(v interface{}) interface{} {
	return reflect.New(reflect.TypeOf(v).Elem()).Interface()
}

func testNewItemSlice(v interface{}) interface{} {
	return reflect.New(reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf(v)), 0, 0).Type()).Interface()
}

func testItemCreate(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	assert.Nil(t, s.SQL().Save(testItems[0]))
}

func testItemCreateInvalid(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	item := testNewItem(refItem)
	reflect.Indirect(reflect.ValueOf(item)).FieldByName("Name").SetString("invalid!")
	assert.Equal(t, ErrInvalidName, s.SQL().Save(item))

	item = testNewItem(refItem)
	reflect.Indirect(reflect.ValueOf(item)).FieldByName("ID").SetString("invalid!")
	assert.Equal(t, ErrInvalidID, s.SQL().Save(item))
}

func testItemGet(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	item := testNewItem(refItem)
	rv := reflect.Indirect(reflect.ValueOf(item))
	assert.Nil(t, s.SQL().Get("name", "item1", item, true))
	assert.NotZero(t, rv.FieldByName("ID").String())
	assert.NotZero(t, rv.FieldByName("Created").Interface())
	assert.Equal(t, testItems[0], item)
}

func testItemGetUnknown(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	item := testNewItem(refItem)
	assert.Equal(t, sqlstorage.ErrItemNotFound, s.SQL().Get("name", "unknown1", item, true))
}

func testItemUpdate(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	desc := "A great item description"

	dv := reflect.Indirect(reflect.ValueOf(testItems[0])).FieldByName("Description")
	dv.Set(reflect.ValueOf(&desc))

	assert.Nil(t, s.SQL().Save(testItems[0]))

	item := testNewItem(refItem)
	rv := reflect.Indirect(reflect.ValueOf(item))
	assert.Nil(t, s.SQL().Get("name", "item1", item, true))
	assert.NotZero(t, rv.FieldByName("ID").String())
	assert.NotZero(t, rv.FieldByName("Created").Interface())
	assert.NotZero(t, rv.FieldByName("Modified").Interface())
	assert.Equal(t, testItems[0], item)

	desc = ""
	dv.Set(reflect.ValueOf(&desc))

	assert.Nil(t, s.SQL().Save(testItems[0]))

	item = testNewItem(refItem)
	rv = reflect.Indirect(reflect.ValueOf(item))
	assert.Nil(t, s.SQL().Get("name", "item1", item, true))
	assert.Nil(t, rv.FieldByName("Description").Interface())
	assert.Equal(t, testItems[0], item)
}

func testItemCount(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	count, err := s.SQL().Count(testNewItem(refItem))
	assert.Nil(t, err)
	assert.Equal(t, 3, count)
}

func testItemList(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	for _, item := range testItems {
		assert.Nil(t, s.SQL().Save(item))
	}

	items := testNewItemSlice(refItem)
	count, err := s.SQL().List(items, nil, []string{"name"}, 0, 0, true)
	assert.Nil(t, err)
	assert.Equal(t, len(testItems), count)
	assert.Equal(t, testItems, testInterfaceToSlice(items))

	items = testNewItemSlice(refItem)
	count, err = s.SQL().List(items, map[string]interface{}{"name": "item1"}, []string{"name"}, 0, 0, true)
	assert.Nil(t, err)
	assert.Equal(t, 1, count)
	assert.Equal(t, testItems[:1], testInterfaceToSlice(items))

	items = testNewItemSlice(refItem)
	count, err = s.SQL().List(items, nil, []string{"name"}, 0, 2, true)
	assert.Nil(t, err)
	assert.Equal(t, len(testItems), count)
	assert.Equal(t, testItems[:2], testInterfaceToSlice(items))

	items = testNewItemSlice(refItem)
	count, err = s.SQL().List(items, nil, []string{"name"}, 1, 1, true)
	assert.Nil(t, err)
	assert.Equal(t, len(testItems), count)
	assert.Equal(t, testItems[1:2], testInterfaceToSlice(items))

	sliceutil.Reverse(testItems)

	items = testNewItemSlice(refItem)
	count, err = s.SQL().List(items, nil, []string{"-name"}, 0, 0, true)
	assert.Nil(t, err)
	assert.Equal(t, len(testItems), count)
	assert.Equal(t, testItems, testInterfaceToSlice(items))

	items = testNewItemSlice(refItem)
	count, err = s.SQL().List(items, nil, []string{"-name"}, 2, 10, true)
	assert.Nil(t, err)
	assert.Equal(t, len(testItems), count)
	assert.Equal(t, testItems[2:], testInterfaceToSlice(items))
}

func testItemDelete(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	assert.Nil(t, s.SQL().Delete(testItems[0]))
	assert.Equal(t, sqlstorage.ErrItemNotFound, s.SQL().Get("name", "item1", testNewItem(refItem), true))
}

func testItemDeleteAll(s *Storage, refItem interface{}, testItems []interface{}, t *testing.T) {
	assert.Nil(t, s.SQL().Delete(testNewItem(refItem)))
}


text:
package hyperbahn

import (
	"bytes"
	"fmt"
	"github.com/uber/tchannel-go/thirdparty/github.com/apache/thrift/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

var GoUnusedProtection__ int

// Attributes:
//  - Message
//  - ServiceName
type NoPeersAvailable struct {
	Message     string `thrift:"message,1,required" db:"message" json:"message"`
	ServiceName string `thrift:"serviceName,2,required" db:"serviceName" json:"serviceName"`
}

func NewNoPeersAvailable() *NoPeersAvailable {
	return &NoPeersAvailable{}
}

func (p *NoPeersAvailable) GetMessage() string {
	return p.Message
}

func (p *NoPeersAvailable) GetServiceName() string {
	return p.ServiceName
}
func (p *NoPeersAvailable) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	var issetMessage bool = false
	var issetServiceName bool = false

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
			issetMessage = true
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
			issetServiceName = true
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	if !issetMessage {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Message is not set"))
	}
	if !issetServiceName {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ServiceName is not set"))
	}
	return nil
}

func (p *NoPeersAvailable) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *NoPeersAvailable) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.ServiceName = v
	}
	return nil
}

func (p *NoPeersAvailable) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("NoPeersAvailable"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *NoPeersAvailable) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:message: ", p), err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.message (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:message: ", p), err)
	}
	return err
}

func (p *NoPeersAvailable) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serviceName", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:serviceName: ", p), err)
	}
	if err := oprot.WriteString(string(p.ServiceName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.serviceName (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:serviceName: ", p), err)
	}
	return err
}

func (p *NoPeersAvailable) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("NoPeersAvailable(%+v)", *p)
}

func (p *NoPeersAvailable) Error() string {
	return p.String()
}

// Attributes:
//  - Message
//  - ServiceName
type InvalidServiceName struct {
	Message     string `thrift:"message,1,required" db:"message" json:"message"`
	ServiceName string `thrift:"serviceName,2,required" db:"serviceName" json:"serviceName"`
}

func NewInvalidServiceName() *InvalidServiceName {
	return &InvalidServiceName{}
}

func (p *InvalidServiceName) GetMessage() string {
	return p.Message
}

func (p *InvalidServiceName) GetServiceName() string {
	return p.ServiceName
}
func (p *InvalidServiceName) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	var issetMessage bool = false
	var issetServiceName bool = false

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
			issetMessage = true
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
			issetServiceName = true
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	if !issetMessage {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Message is not set"))
	}
	if !issetServiceName {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ServiceName is not set"))
	}
	return nil
}

func (p *InvalidServiceName) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *InvalidServiceName) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.ServiceName = v
	}
	return nil
}

func (p *InvalidServiceName) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("InvalidServiceName"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *InvalidServiceName) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:message: ", p), err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.message (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:message: ", p), err)
	}
	return err
}

func (p *InvalidServiceName) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serviceName", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:serviceName: ", p), err)
	}
	if err := oprot.WriteString(string(p.ServiceName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.serviceName (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:serviceName: ", p), err)
	}
	return err
}

func (p *InvalidServiceName) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InvalidServiceName(%+v)", *p)
}

func (p *InvalidServiceName) Error() string {
	return p.String()
}

// Attributes:
//  - ServiceName
type DiscoveryQuery struct {
	ServiceName string `thrift:"serviceName,1,required" db:"serviceName" json:"serviceName"`
}

func NewDiscoveryQuery() *DiscoveryQuery {
	return &DiscoveryQuery{}
}

func (p *DiscoveryQuery) GetServiceName() string {
	return p.ServiceName
}
func (p *DiscoveryQuery) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	var issetServiceName bool = false

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
			issetServiceName = true
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	if !issetServiceName {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ServiceName is not set"))
	}
	return nil
}

func (p *DiscoveryQuery) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.ServiceName = v
	}
	return nil
}

func (p *DiscoveryQuery) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("DiscoveryQuery"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DiscoveryQuery) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serviceName", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serviceName: ", p), err)
	}
	if err := oprot.WriteString(string(p.ServiceName)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.serviceName (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serviceName: ", p), err)
	}
	return err
}

func (p *DiscoveryQuery) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DiscoveryQuery(%+v)", *p)
}

// Attributes:
//  - Ipv4
type IpAddress struct {
	Ipv4 *int32 `thrift:"ipv4,1" db:"ipv4" json:"ipv4,omitempty"`
}

func NewIpAddress() *IpAddress {
	return &IpAddress{}
}

var IpAddress_Ipv4_DEFAULT int32

func (p *IpAddress) GetIpv4() int32 {
	if !p.IsSetIpv4() {
		return IpAddress_Ipv4_DEFAULT
	}
	return *p.Ipv4
}
func (p *IpAddress) CountSetFieldsIpAddress() int {
	count := 0
	if p.IsSetIpv4() {
		count++
	}
	return count

}

func (p *IpAddress) IsSetIpv4() bool {
	return p.Ipv4 != nil
}

func (p *IpAddress) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *IpAddress) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Ipv4 = &v
	}
	return nil
}

func (p *IpAddress) Write(oprot thrift.TProtocol) error {
	if c := p.CountSetFieldsIpAddress(); c != 1 {
		return fmt.Errorf("%T write union: exactly one field must be set (%d set).", p, c)
	}
	if err := oprot.WriteStructBegin("IpAddress"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *IpAddress) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetIpv4() {
		if err := oprot.WriteFieldBegin("ipv4", thrift.I32, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ipv4: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Ipv4)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.ipv4 (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ipv4: ", p), err)
		}
	}
	return err
}

func (p *IpAddress) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("IpAddress(%+v)", *p)
}

// Attributes:
//  - IP
//  - Port
type ServicePeer struct {
	IP   *IpAddress `thrift:"ip,1,required" db:"ip" json:"ip"`
	Port int32      `thrift:"port,2,required" db:"port" json:"port"`
}

func NewServicePeer() *ServicePeer {
	return &ServicePeer{}
}

var ServicePeer_IP_DEFAULT *IpAddress

func (p *ServicePeer) GetIP() *IpAddress {
	if !p.IsSetIP() {
		return ServicePeer_IP_DEFAULT
	}
	return p.IP
}

func (p *ServicePeer) GetPort() int32 {
	return p.Port
}
func (p *ServicePeer) IsSetIP() bool {
	return p.IP != nil
}

func (p *ServicePeer) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	var issetIP bool = false
	var issetPort bool = false

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
			issetIP = true
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
			issetPort = true
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	if !issetIP {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field IP is not set"))
	}
	if !issetPort {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Port is not set"))
	}
	return nil
}

func (p *ServicePeer) ReadField1(iprot thrift.TProtocol) error {
	p.IP = &IpAddress{}
	if err := p.IP.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.IP), err)
	}
	return nil
}

func (p *ServicePeer) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Port = v
	}
	return nil
}

func (p *ServicePeer) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ServicePeer"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ServicePeer) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("ip", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ip: ", p), err)
	}
	if err := p.IP.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.IP), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ip: ", p), err)
	}
	return err
}

func (p *ServicePeer) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("port", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:port: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Port)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.port (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:port: ", p), err)
	}
	return err
}

func (p *ServicePeer) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ServicePeer(%+v)", *p)
}

// Attributes:
//  - Peers
type DiscoveryResult_ struct {
	Peers []*ServicePeer `thrift:"peers,1,required" db:"peers" json:"peers"`
}

func NewDiscoveryResult_() *DiscoveryResult_ {
	return &DiscoveryResult_{}
}

func (p *DiscoveryResult_) GetPeers() []*ServicePeer {
	return p.Peers
}
func (p *DiscoveryResult_) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	var issetPeers bool = false

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
			issetPeers = true
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	if !issetPeers {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Peers is not set"))
	}
	return nil
}

func (p *DiscoveryResult_) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*ServicePeer, 0, size)
	p.Peers = tSlice
	for i := 0; i < size; i++ {
		_elem0 := &ServicePeer{}
		if err := _elem0.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem0), err)
		}
		p.Peers = append(p.Peers, _elem0)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *DiscoveryResult_) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("DiscoveryResult"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *DiscoveryResult_) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("peers", thrift.LIST, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:peers: ", p), err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Peers)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Peers {
		if err := v.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:peers: ", p), err)
	}
	return err
}

func (p *DiscoveryResult_) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DiscoveryResult_(%+v)", *p)
}


text:
/*jslint anon:true, sloppy:true, nomen:true*/
/*global YUI*/
YUI.add('blogmocked-model-yql', function (Y, NAME) {

    Y.mojito.models[NAME] = {
        init: function (config) {
            this.config = config;
            this.data = [ { title: "Blog Test", "link": "http://www.yuiblog.com/", "creator": "YUI blogger", "description": "Test blog post.", "pubDate": new Date() }];
        },
        getData: function (params, feedURL, callback) {
           Y.log("Returning mocked data.", "info", NAME);
           callback(null, this.data);
        }
    };
}, '0.0.1', {requires: ['yql', 'substitute']});


text:
PACKAGES=("syllo" "input" "videoray" "syllo_rqt" "blueview" "sandbox" "syllo_uwsim" "underwater")

# Generate setenv.sh file on every build
ENV_FILE_NAME="./setenv.sh"
touch ${ENV_FILE_NAME}
chmod +x ${ENV_FILE_NAME}
ENV_FILE="$(readlink -f ${ENV_FILE_NAME})"

THIS_FILE="$(readlink -f ./build.sh)"
echo "#!/bin/bash" > ${ENV_FILE}
echo "# DO NOT EDIT THIS FILE" >> ${ENV_FILE}
echo "# Automatically generated from:" >> ${ENV_FILE}
echo "# ${THIS_FILE}" >> ${ENV_FILE}
echo "" >> ${ENV_FILE}

# Descend into each catkin package and build it
for i in "${PACKAGES[@]}"
do
    :
    pushd "./src/${i}/catkin_ws" >& /dev/null
     # Build the project
    ./build.sh

    # Source the setup.bash script for this project for later projects
    # that will require the current project
    PKG_ENV_FILE="$(readlink -f ./devel/setup.bash)"
    source "${PKG_ENV_FILE}"

    # Add the source line to the high-level setenv.sh script
    echo "source ${PKG_ENV_FILE}" >> ${ENV_FILE}

    popd >& /dev/null
done

# Add location of Gazebo models
#echo 'export GAZEBO_MODEL_PATH=~/repos/humans/src/underwater/catkin_ws/src:${GAZEBO_MODEL_PATH}' >> ${ENV_FILE}

echo
echo "=================================================="
echo "  Add the following lines to your .bashrc file    "
echo "=================================================="
echo
echo "CATKIN_WS1_SETUP="${ENV_FILE}
echo 'if [ -f ${CATKIN_WS1_SETUP} ]; then'
echo 'source ${CATKIN_WS1_SETUP}'
echo 'fi'
echo


text:
public final class Foo /* Foo*/ {
  @org.jetbrains.annotations.NotNull()
  private final Foo b;

  @org.jetbrains.annotations.NotNull()
  private final java.lang.Object arrayConst;

  @org.jetbrains.annotations.NotNull()
  private final kotlin.jvm.functions.Function1<java.lang.Integer, java.lang.Integer> sum;

  @org.jetbrains.annotations.NotNull()
  private java.lang.String name;

  @org.jetbrains.annotations.NotNull()
  private java.lang.String protectedWithPrivateSet;

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String CONSTANT_WITH_ESCAPES = "A\tB\nC\rD'E\"F\\G$H" /* initializer type: java.lang.String */ /* constant value A	B
  C
  D'E"F\G$H */;

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String SUBSYSTEM_DEPRECATED = "This subsystem is deprecated" /* initializer type: java.lang.String */ /* constant value This subsystem is deprecated */;

  @org.jetbrains.annotations.NotNull()
  public static final Foo.Companion Companion;

  @org.jetbrains.annotations.Nullable()
  private java.lang.Boolean isEmptyMutable;

  @org.jetbrains.annotations.Nullable()
  private java.lang.Boolean islowercase;

  @org.jetbrains.annotations.Nullable()
  private java.lang.Integer getInt;

  @org.jetbrains.annotations.Nullable()
  private java.lang.Integer isEmptyInt;

  private boolean c;

  private final error.NonExistentClass d;

  private final error.NonExistentClass delegatedProp$delegate;

  private final error.NonExistentClass delegatedProp2$delegate;

  private final error.NonExistentClass lazyProp$delegate;

  private final error.NonExistentClass privateDelegated$delegate;

  private final int f1$1;

  private final java.lang.Void intConst;

  private final long e;

  private int counter;

  private int f2;

  private int internalWithPrivateSet;

  private int privateVarWithPrivateSet;

  private java.lang.Object privateVarWithGet;

  private java.lang.String internalVarPrivateSet;

  private java.lang.String noAccessors;

  private static final error.NonExistentClass contextBean;

  private static final int f1;

  private static int prop7;

  protected java.lang.String protectedLateinitVar;

  public error.NonExistentClass subject;

  @org.jetbrains.annotations.NotNull()
  protected final java.lang.String getProtectedLateinitVar();//  getProtectedLateinitVar()

  @org.jetbrains.annotations.NotNull()
  protected final java.lang.String getProtectedWithPrivateSet();//  getProtectedWithPrivateSet()

  @org.jetbrains.annotations.NotNull()
  public final Foo getB();//  getB()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.Object getArrayConst();//  getArrayConst()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String getDelegatedProp();//  getDelegatedProp()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String getInternalVarPrivateSet$light_idea_test_case();//  getInternalVarPrivateSet$light_idea_test_case()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String getLazyProp();//  getLazyProp()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String getName();//  getName()

  @org.jetbrains.annotations.NotNull()
  public final java.lang.String getStringRepresentation$light_idea_test_case();//  getStringRepresentation$light_idea_test_case()

  @org.jetbrains.annotations.NotNull()
  public final kotlin.jvm.functions.Function1<java.lang.Integer, java.lang.Integer> getSum();//  getSum()

  @org.jetbrains.annotations.Nullable()
  public final java.lang.Boolean getIslowercase();//  getIslowercase()

  @org.jetbrains.annotations.Nullable()
  public final java.lang.Boolean isEmptyMutable();//  isEmptyMutable()

  @org.jetbrains.annotations.Nullable()
  public final java.lang.Integer getCounter2();//  getCounter2()

  @org.jetbrains.annotations.Nullable()
  public final java.lang.Integer getGetInt();//  getGetInt()

  @org.jetbrains.annotations.Nullable()
  public final java.lang.Integer isEmptyInt();//  isEmptyInt()

  private final int getPrivateDelegated();//  getPrivateDelegated()

  private final java.lang.String getPrivateValWithGet();//  getPrivateValWithGet()

  private final void setPrivateDelegated(int);//  setPrivateDelegated(int)

  protected final int getF2();//  getF2()

  protected final long getE();//  getE()

  protected final void setF2(int);//  setF2(int)

  protected final void setProtectedLateinitVar(@org.jetbrains.annotations.NotNull() java.lang.String);//  setProtectedLateinitVar(java.lang.String)

  public  Foo(int, @org.jetbrains.annotations.NotNull() Foo, boolean, error.NonExistentClass, long);//  .ctor(int, Foo, boolean, error.NonExistentClass, long)

  public final boolean getC();//  getC()

  public final boolean isEmpty();//  isEmpty()

  public final error.NonExistentClass getSubject();//  getSubject()

  public final int getCounter();//  getCounter()

  public final int getDelegatedProp2();//  getDelegatedProp2()

  public final int getF1();//  getF1()

  public final int getIntProp(int);//  getIntProp(int)

  public final int getInternalWithPrivateSet$light_idea_test_case();//  getInternalWithPrivateSet$light_idea_test_case()

  public final java.lang.Void getIntConst();//  getIntConst()

  public final void setC(boolean);//  setC(boolean)

  public final void setCounter(int);//  setCounter(int)

  public final void setCounter2(@org.jetbrains.annotations.Nullable() java.lang.Integer);//  setCounter2(java.lang.Integer)

  public final void setDelegatedProp(@org.jetbrains.annotations.NotNull() java.lang.String);//  setDelegatedProp(java.lang.String)

  public final void setDelegatedProp2(int);//  setDelegatedProp2(int)

  public final void setEmptyInt(@org.jetbrains.annotations.Nullable() java.lang.Integer);//  setEmptyInt(java.lang.Integer)

  public final void setEmptyMutable(@org.jetbrains.annotations.Nullable() java.lang.Boolean);//  setEmptyMutable(java.lang.Boolean)

  public final void setGetInt(@org.jetbrains.annotations.Nullable() java.lang.Integer);//  setGetInt(java.lang.Integer)

  public final void setIslowercase(@org.jetbrains.annotations.Nullable() java.lang.Boolean);//  setIslowercase(java.lang.Boolean)

  public final void setLazyProp(@org.jetbrains.annotations.NotNull() java.lang.String);//  setLazyProp(java.lang.String)

  public final void setName(@org.jetbrains.annotations.NotNull() java.lang.String);//  setName(java.lang.String)

  public final void setStringRepresentation$light_idea_test_case(@org.jetbrains.annotations.NotNull() java.lang.String);//  setStringRepresentation$light_idea_test_case(java.lang.String)

  public final void setSubject(error.NonExistentClass);//  setSubject(error.NonExistentClass)

  class Companion ...

  }

public static final class Companion /* Foo.Companion*/ {
  private  Companion();//  .ctor()

  public final int getF1();//  getF1()

  public final int getProp3();//  getProp3()

  public final int getProp7();//  getProp7()

  public final void setProp7(int);//  setProp7(int)

}

public final class MyProperty /* MyProperty*/<T>  {
  public  MyProperty();//  .ctor()

  public final int getValue(T, @org.jetbrains.annotations.NotNull() kotlin.reflect.KProperty<?>);//  getValue(T, kotlin.reflect.KProperty<?>)

  public final void setValue(T, @org.jetbrains.annotations.NotNull() kotlin.reflect.KProperty<?>, int);//  setValue(T, kotlin.reflect.KProperty<?>, int)

}

public final class Modifiers /* Modifiers*/ {
  private final int plainField;

  public  Modifiers();//  .ctor()

  public final int getPlainField();//  getPlainField()

}

public abstract interface A /* A*/ {
  protected abstract int getInt1();//  getInt1()

  public abstract int getInt2();//  getInt2()

  public abstract void setInt2$light_idea_test_case(int);//  setInt2$light_idea_test_case(int)

}