text:
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <ProgressBar
        android:id="@+id/progress"
        android:layout_gravity="center"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <LinearLayout
    	android:id="@+id/linear"
    	android:layout_width="match_parent"
    	android:layout_height="match_parent"
    	android:orientation="vertical"
   		android:visibility="gone">
    	<TextView
    	    android:id="@+id/name"
        	android:layout_width="match_parent"
       		android:layout_height="wrap_content"
       		android:padding="10dp"
       		android:textSize="25sp"
       		android:gravity="center"
       		android:textStyle="bold"
       		android:background="#11000000"/>
  		<ListView
     		android:id="@android:id/list"
     		android:layout_width="match_parent"
     		android:layout_height="match_parent"/>
    </LinearLayout>
</FrameLayout>


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.amdatu.remote.discovery.slp;

import java.net.URL;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

import org.amdatu.remote.discovery.AbstractHttpEndpointDiscovery;
import org.amdatu.remote.discovery.HttpEndpointDiscoveryConfiguration;
import org.livetribe.slp.Attributes;
import org.livetribe.slp.SLP;
import org.livetribe.slp.Scopes;
import org.livetribe.slp.ServiceInfo;
import org.livetribe.slp.ServiceType;
import org.livetribe.slp.ServiceURL;
import org.livetribe.slp.sa.ServiceAgent;
import org.livetribe.slp.settings.Keys;
import org.livetribe.slp.settings.MapSettings;
import org.livetribe.slp.ua.UserAgentClient;
import org.osgi.service.remoteserviceadmin.EndpointDescription;

/**
 * SLP implementation of service endpoint based discovery. This type of discovery discovers HTTP endpoints
 * that provide published services based on the {@link EndpointDescription} extender format.
 *
 * @author Amdatu Project Team
 */
public final class SlpEndpointDiscovery extends AbstractHttpEndpointDiscovery<HttpEndpointDiscoveryConfiguration> {

    public static final String DISCOVERY_NAME = "Amdatu Remote Service Endpoint (SLP)";
    public static final String DISCOVERY_TYPE = "slp";

    private final static String SERVICE_NAME = "service:osgi.remote:http";
    private final static ServiceType SERVICE_TYPE = new ServiceType(SERVICE_NAME);
    private final static String SERVICE_LANGUAGES = Locale.ENGLISH.getLanguage();

    private final Map<URL, ServiceInfo> m_services = new HashMap<URL, ServiceInfo>();

    private volatile ServiceAgent m_agent;
    private volatile UserAgentClient m_client;
    private volatile SlpUpdater m_updater;

    public SlpEndpointDiscovery(HttpEndpointDiscoveryConfiguration configuration) {
        super(DISCOVERY_TYPE, configuration);
    }

    @Override
    protected void startComponent() throws Exception {
        super.startComponent();

        Dictionary<String, Object> properties = new Hashtable<String, Object>();
        properties.put(Keys.PORT_KEY.getKey(), 9999);
        properties.put(Keys.UA_UNICAST_PREFER_TCP.getKey(), "true");

        if (m_agent != null && m_agent.isRunning()) {
            m_agent.stop();
        }
        m_agent = createServiceAgent(this.getClass().getClassLoader(), properties);
        m_agent.start();
        m_client = createUserAgentClient(this.getClass().getClassLoader(), properties);

        String url = "service:osgi.remote:" + getConfiguration().getBaseUrl().toExternalForm();
        ServiceURL serviceURL = new ServiceURL(url, 10);
        ServiceInfo serviceInfo = new ServiceInfo(serviceURL, SERVICE_LANGUAGES, Scopes.DEFAULT, Attributes.NONE);
        m_agent.register(serviceInfo);

        m_updater = new SlpUpdater();
    }

    @Override
    protected void stopComponent() throws Exception {
        try {
            m_agent.stop();
        }
        catch (Exception e) {
            logWarning("Exception while stopping", e);
        }
        m_agent = null;
        m_client = null;

        try {
            m_updater.cancel();
        }
        catch (Exception e) {
            logWarning("Exception while stopping", e);
        }
        m_updater = null;

        for (ServiceInfo service : m_services.values()) {
            removeDiscoveryEndpoint(service.getKey().toString());
        }
        m_services.clear();

        super.stopComponent();
    }

    /**
     * Create a {@link ServiceAgent} using the specified arguments.
     *
     * @param cl the classLoader
     * @param port the port
     * @return the agent
     */
    private static ServiceAgent createServiceAgent(ClassLoader cl, Dictionary<String, Object> properties) {
        MapSettings settings = getSettings(properties);
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoader(cl);
        try {
            return SLP.newServiceAgent(settings);
        }
        catch (Throwable t) {
            t.printStackTrace();
            throw t;
        }
        finally {
            Thread.currentThread().setContextClassLoader(classLoader);
        }
    }

    /**
     * Create a {@link UserAgentClient} using the specified arguments.
     *
     * @param cl
     * @param properties
     * @return the client
     */
    private static UserAgentClient createUserAgentClient(ClassLoader cl, Dictionary<String, Object> properties) {

        MapSettings settings = getSettings(properties);
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoader(cl);
        try {
            return SLP.newUserAgentClient(settings);
        }
        finally {
            Thread.currentThread().setContextClassLoader(classLoader);
        }
    }

    private static MapSettings getSettings(Dictionary<String, ?> properties) {
        MapSettings settings = new MapSettings();
        Object slpPort = properties.get(Keys.PORT_KEY.getKey());
        if (slpPort != null) {
            settings.put(Keys.PORT_KEY, Keys.PORT_KEY.convert(slpPort));
        }
        Object slpScopes = properties.get(Keys.SCOPES_KEY.getKey());
        if (slpScopes != null) {
            settings.put(Keys.SCOPES_KEY, Keys.SCOPES_KEY.convert(slpScopes));
        }
        Object slpAddress = properties.get(Keys.ADDRESSES_KEY.getKey());
        if (slpAddress != null) {
            settings.put(Keys.ADDRESSES_KEY, Keys.ADDRESSES_KEY.convert(slpAddress));
        }
        Object slpMtu = properties.get(Keys.MAX_TRANSMISSION_UNIT_KEY.getKey());
        if (slpMtu != null) {
            settings.put(Keys.MAX_TRANSMISSION_UNIT_KEY, Keys.MAX_TRANSMISSION_UNIT_KEY.convert(slpMtu));
        }
        Object tcp = properties.get(Keys.UA_UNICAST_PREFER_TCP.getKey());
        if (tcp != null) {
            settings.put(Keys.UA_UNICAST_PREFER_TCP, Keys.UA_UNICAST_PREFER_TCP.convert(tcp));
        }
        return settings;
    }

    private class SlpUpdater implements Runnable {

        private final ScheduledExecutorService m_executor;
        private final ScheduledFuture<?> m_future;

        public SlpUpdater() {
            m_executor = Executors.newSingleThreadScheduledExecutor();
            m_future = m_executor.scheduleAtFixedRate(this, 1, 5, TimeUnit.SECONDS);
        }

        public void cancel() {
            m_future.cancel(false);
            m_executor.shutdownNow();
        }

        @Override
        public void run() {
            UserAgentClient userAgentClient = m_client;
            if (userAgentClient == null) {
                return;
            }

            List<ServiceInfo> services =
                userAgentClient.findServices(SERVICE_TYPE, SERVICE_LANGUAGES, Scopes.NONE, null);
            for (ServiceInfo service : services) {
                service.setRegistered(true);
                try {
                    URL url = new URL(service.getServiceURL().getURL().replaceFirst(SERVICE_NAME, "http"));
                    if (!m_services.containsKey(url)) {
                        addDiscoveryEndpoint(service.getKey().toString(), url);
                    }
                    m_services.put(url, service);
                }
                catch (Exception e) {
                    e.printStackTrace();
                }
            }

            long now = System.currentTimeMillis();
            List<String> removeIds = new ArrayList<String>();
            for (ServiceInfo serviceInfo : m_services.values()) {
                if (serviceInfo.isExpiredAsOf(now)) {
                    removeIds.add(serviceInfo.getKey().toString());
                }
            }
            for (String removeId : removeIds) {
                m_services.remove(removeId);
                removeDiscoveryEndpoint(removeId);
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
title: Rotate Client Secret
description: Learn how to rotate an application's client secret using the Auth0 Management Dashboard.
topics:
  - applications
  - client-secrets
  - dashboard
contentType:
  - how-to
useCase:
  - build-an-app
---
# Rotate Client Secret

This guide will show you how to change an application's client secret using Auth0's Dashboard. This task can also be performed [using the Management API](/api/management/guides/applications/rotate-client-secret).

::: note
The global client secret can also be rotated via the Dashboard. Your global client ID and secret can be found in your [Advanced Tenant Settings](${manage_url}/#/tenant/advanced).
:::

1. Navigate to the [Applications](${manage_url}/#/applications) page in the [Auth0 Dashboard](${manage_url}/), and click the name of the Application to view.

![View Applications](/media/articles/dashboard/guides/app-list.png)

2. Scroll to the bottom of the Application Settings page and under **Danger Zone**, you will see the Rotate secret option. Click the **Rotate** button to rotate the client's secret.

![Rotate Client Secret](/media/articles/dashboard/guides/rotate-client-secret.png)

You can view your new secret by selecting the **Reveal client secret** checkbox.

3. Update authorized applications

After you rotate your client secret, you must update any authorized applications with the new value.


text:
/**
 * @module	Calendar
 */

/**
 * Handle week view
 *
 * @namespace	Todoyu.Ext.calendar.Week
 */
Todoyu.Ext.calendar.Week	= {

	/**
	 * Reference to extension
	 *
	 * @property	ext
	 * @type		Object
	 */
	ext: Todoyu.Ext.calendar,

	/**
	 * Check whether weekend is displayed
	 *
	 * @method	isWeekendDisplayed
	 * @return	{Boolean}
	 */
	isWeekendDisplayed: function() {
		return this.getNumDays() === 7;
	},

	/**
	 * Check whether compact view is active
	 *
	 * @method	isCompactView
	 * @return	{Boolean}
	 */
	isCompactView: function() {
		return this.getNumDays() === 5;
	},

	/**
	 * Check whether today is displayed
	 *
	 * @method	isTodayDisplayed
	 * @return	{Boolean}
	 */
	isTodayDisplayed: function() {
		return $('gridHeader') && $('gridHeader').down('.today');
	},

	/**
	 * Check whether first day of week is sunday
	 *
	 * @return	{Boolean}
	 */
	isFirstDaySunday: function() {
		return Todoyu.Config.system.firstDayOfWeek === 0;
	},

	/**
	 * Get number of displayed days
	 *
	 * @method	getNumDays
	 * @return	{Number}
	 */
	getNumDays: function() {
		return this.ext.CalendarBody.getAmountDisplayedDays();
	},

	/**
	 * Get snap config for drag and drop in week view
	 *
	 * @method	getDragDropSnap
	 * @param	{Number}		x
	 * @param	{Number}		y
	 * @param	{Draggable}		draggable
	 * @return	{Number[]}
	 */
	getDragDropSnap: function(x, y, draggable) {
		var verSnap	= this.ext.DragDrop.verticalHourSnap;
		var horSnap, horMax;

		if( this.isWeekendDisplayed() ) {
			horSnap	= 124.7;
			horMax	= 750;
		} else {
			horSnap	= 175.7;
			horMax	= 710;
		}

		x = Math.round(x / horSnap) * horSnap;
		y = Math.round(y / verSnap) * verSnap;

			// Keep in horizontal range
		if( x < 0 ) {
			x = 0;
		} else if( x > horMax ) {
			x = horMax;
		}

			// Keep in vertical range
		if( y < 0 ) {
			y = 0;
		}

		return [x, y];
	},

	/**
	 * Get options for drag 'n drop
	 *
	 * @method	getDragDropOptions
	 * @return	{Object}
	 */
	getDragDropOptions: function() {
		return {
			snap: this.getDragDropSnap.bind(this)
		};
	},

	/**
	 * Initialize day events drag and drop in week
	 */
	initDayEventsDragdrop: function() {
		var options			= Object.clone(this.ext.DragDrop.defaultDraggableOptions);

		options.constraint	= 'horizontal';
		options.snap		= this.isCompactView() ? 175 : 126; // Day pixel-width
		options.onStart		= this.onStartDragDayEvent.bind(this);
		options.onEnd		= this.onEndDragDayEvent.bind(this);

		this.getDayEvents().each(function(eventElement){
			new Draggable(eventElement, options);
		}, this);
	},

	/**
	 * Get all all-day long event elements, except the noAccess classed
	 *
	 * @method	getDayEvents
	 * @return	{Element[]}
	 */
	getDayEvents: function() {
		return this.ext.DragDrop.getDayEvents();
	},

	/**
	 * Handler when dragging event item starts
	 *
	 * @method	onStartDragDayEvent
	 * @param	{Object}		dragInfo		Information about dragging
	 * @param	{Event}			event
	 */
	onStartDragDayEvent: function(dragInfo, event) {
		this.ext.DragDrop.initDraggableRevertToOrigin(dragInfo.element);
		Todoyu.QuickInfo.hide(true);
	},

	/**
	 * Handler when dragging of all-day event ends
	 *
	 * @method	onEndDragDayEvent
	 * @param	{Object}		dragInfo		Information about dragging
	 * @param	{Event}			domEvent
	 */
	onEndDragDayEvent: function(dragInfo, domEvent) {
		var idEvent	= dragInfo.element.id.split('-').last();

		this.saveAllDayEventDrop(idEvent, dragInfo);
	},

	/**
	 * Get week start depending on first day of week and complex view
	 *
	 * @return	{Date}
	 */
	getWeekStart: function() {
		var weekStart = this.ext.getWeekStart();

		if( this.isFirstDaySunday() && this.isCompactView() ) {
			weekStart.addDays(1);
		}

		return weekStart;
	},

	/**
	 * Save new position after dropping of all-day event
	 *
	 * @method	saveWeekDrop
	 * @param	{Number}	idEvent
	 * @param	{Object}	dragInfo
	 */
	saveAllDayEventDrop: function(idEvent, dragInfo) {
		var dayWidth		= this.getDayColWidth(); // amountDaysInWeek === 7 ? 88 : 123;
		var weekStart		= this.getWeekStart();
		var offsetLeft		= dragInfo.element.positionedOffset().left;
		var dayOfWeek		= Math.floor((offsetLeft) / dayWidth);

		if( dayOfWeek >= 0 && dayOfWeek < this.getNumDays() ) {
				// Shift starting day date, keep starting time of day
			var dropDate	= weekStart.addDays(dayOfWeek, true);

			this.ext.DragDrop.saveDropping('week', idEvent, dropDate);
		} else {
			dragInfo.element.revertToOrigin();
		}
	},

	/**
	 * Get width of day column
	 *
	 * @method	getDayColWidth
	 * @return	{Number}
	 */
	getDayColWidth: function() {
		return $('tgTable').down('.dayCol').getWidth();
	},

	/**
	 * Calculate date for drop position
	 *
	 * @method	getDropDate
	 * @param	{Object}	dragInfo
	 * @return	{Date}
	 */
	getDropDate: function(dragInfo) {
		var timeColWidth= 42;
		var dayWidth	= this.getDayColWidth();
		var offset		= dragInfo.element.positionedOffset();
			// Offset fix (offset seems to be shifted one hour)
		offset.top	+= this.ext.hourHeight;

		var weekStart	= this.ext.getWeekStartTime();
		var dayIndex	= Math.round(Math.abs(offset.left - timeColWidth) / dayWidth);

		var dayHours	= Math.round((offset.top / this.ext.hourHeight) * 4) / 4;
		var timestamp	= weekStart + Todoyu.Time.seconds.day * dayIndex + dayHours * Todoyu.Time.seconds.hour;

		return new Date(timestamp * 1000);
	},

	/**
	 * Get date for event position
	 *
	 * @method	getDateForPosition
	 * @param	{Number}	x
	 * @param	{Number}	y
	 * @return	{Number}
	 */
	getDateForPosition: function(x, y) {
		var weekStart	= this.ext.getWeekStartTime();
		var dayIndex	= this.getDayIndex(x);
		var offsetTop	= this.ext.CalendarBody.getFixedTopOffset(y);
		var dayTime		= this.ext.CalendarBody.getDayOffset(offsetTop);
		var dayShift	= dayIndex * Todoyu.Time.seconds.day;

		return weekStart + dayShift + dayTime;
	},

	/**
	 * Get day index for week
	 *
	 * @method	getDayIndex
	 * @param	{Number}	leftOffset
	 */
	getDayIndex: function(leftOffset) {
		var boxOffsetLeft	= $('calendarBody').cumulativeOffset().left + 43;
		var dayColWidth		= this.getDayColWidth();
		var offsetLeft		= leftOffset - boxOffsetLeft;
		var dayIndex		= Math.floor(offsetLeft / dayColWidth);
		dayIndex			= dayIndex < 0 ? 0 : dayIndex < this.getNumDays() ? dayIndex : this.getNumDays() - 1;

		return dayIndex;
	}

};


text:
require 'minigit'

module SimpleChangelog
  describe Repository do
    before(:each) do
      @repo = double('repository', tags: [])
      @repo.stub(:capturing) { @repo }
      @repo.stub(:log).with(anything).and_return ''

      MiniGit.should_receive(:new).with(anything).and_return(@repo)
    end

    let(:empty_repo) { Repository.new 'empty'  }

    describe :empty_repo do
      subject { empty_repo }

      it { should respond_to :load_history }
      its(:load_history) { should be_kind_of(Hash) }
    end
  end
end


text:
<?php
namespace Aquarium\Resources\Utils;

class ResourceCollectionTest extends \PHPUnit_Framework_TestCase
{
	public function test_add()
	{
		$collection = new ResourceCollection();

		$collection->add('a');
		$collection->add('b');
		$this->assertEquals(['a', 'b'], $collection->get());
	}

	public function test_add_SameResourceIgnored()
	{
		$collection = new ResourceCollection();

		$collection->add('a');
		$collection->add('a');
		$this->assertEquals(['a'], $collection->get());
	}

	public function test_add_ReturnSelf()
	{
		$collection = new ResourceCollection();
		$this->assertSame($collection, $collection->add('a'));

		// Duplicate value still return self.
		$this->assertSame($collection, $collection->add('a'));
	}

	public function test_add_AddArray()
	{
		$collection = new ResourceCollection();
		$collection->add(['a', 'b', 'c']);

		$this->assertEquals(['a', 'b', 'c'], $collection->get());
	}

	public function test_add_AddArrayWithAlreadyExistingValues()
	{
		$collection = new ResourceCollection();
		$collection->add(['a', 'b', 'c']);
		$collection->add(['n', 'b', 'a']);

		$this->assertEquals(['a', 'b', 'c', 'n'], $collection->get());
	}

	public function test_add_AddArray_ReturnsSelf()
	{
		$collection = new ResourceCollection();
		$collection->add(['a', 'b', 'c']);
		$collection->add(['n', 'b', 'a']);

		$this->assertEquals(['a', 'b', 'c', 'n'], $collection->get());
	}

	public function test_add_AddResourceCollection()
	{
		$collection = new ResourceCollection();
		$collection->add(['a', 'b', 'c']);

		$added = new ResourceCollection();
		$added->add(['n', 'b', 'h']);

		$collection->add($added);

		$this->assertEquals(['a', 'b', 'c', 'n', 'h'], $collection->get());
	}

	public function test_hasResource()
	{
		$collection = new ResourceCollection();

		$collection->add('a');
		$collection->add('b');

		$this->assertTrue($collection->hasResource('a'));
		$this->assertFalse($collection->hasResource('c'));
	}

	public function test_hasAny()
	{
		$collection = new ResourceCollection();

		$this->assertFalse($collection->hasAny());

		$collection->add('a');

		$this->assertTrue($collection->hasAny());
	}

	public function test_replace_ElementNotFound()
	{
		$collection = new ResourceCollection();
		$collection->add('a');
		$collection->replace('b', 'c');

		$this->assertEquals(['a'], $collection->get());
	}

	public function test_replace_SingleElement()
	{
		$collection = new ResourceCollection();
		$collection->add('a');
		$collection->replace('a', 'c');

		$this->assertEquals(['c'], $collection->get());
	}

	public function test_replace_NumberOfElements()
	{
		$collection = new ResourceCollection();
		$collection->add('a')->add('b')->add('c');
		$collection->replace('b', 'd');

		$this->assertEquals(['a', 'd', 'c'], $collection->get());
	}

	public function test_remove_ElementNotFound()
	{
		$collection = new ResourceCollection();
		$collection->add('a');
		$collection->remove('b');

		$this->assertEquals(['a'], $collection->get());
	}

	public function test_remove_ElementFound()
	{
		$collection = new ResourceCollection();
		$collection->add('a')->add('b');
		$collection->remove('b');

		$this->assertEquals(['a'], $collection->get());
	}

	public function test_remove_SingleElementAsArray()
	{
		$collection = new ResourceCollection();
		$collection->add('b')->add('c');
		$collection->remove(['b']);

		$this->assertEquals(['c'], $collection->get());
	}

	public function test_remove_NumberOfElements()
	{
		$collection = new ResourceCollection();
		$collection->add('a')->add('b')->add('c')->add('d');
		$collection->remove(['b', 'd']);

		$this->assertEquals(['a', 'c'], $collection->get());
	}

	public function test_count()
	{
		$collection = new ResourceCollection();

		$this->assertEquals(0, $collection->count());

		$collection->add('a');
		$collection->add('b');
		$collection->add('c');
		$collection->add('a');

		$this->assertEquals(3, $collection->count());
	}

	public function test_get_NoData_ReturnEmptyArray()
	{
		$collection = new ResourceCollection();
		$this->assertEmpty($collection->get());
	}

	public function test_get_HasData_ReturnEmptyArray()
	{
		$collection = new ResourceCollection();
		$collection->add('a');
		$this->assertEquals(['a'], $collection->get());
	}

	public function test_get_FilterUsed_FilterApplied()
	{
		$collection = new ResourceCollection();
		$collection->add('a')->add('1abc')->add('abc')->add('1nnn');
		$this->assertEquals(['1abc', '1nnn'], $collection->get('1*'));
	}

	public function test_setToRelativePath_CollectionEmpty()
	{
		$collection = new ResourceCollection();
		$collection->truncatePath('a');
	}

	public function test_setToRelativePath_PathFixed()
	{
		$collection = new ResourceCollection();
		$collection->add('/a/1')->add('/a/bc/dd');
		$collection->truncatePath('/a/');

		$this->assertEquals(['1', 'bc/dd'], $collection->get());
	}

	public function test_setToRelativePath_DirectorySeparatorAddedToDirPath()
	{
		$collection = new ResourceCollection();
		$collection->add('/a/1');
		$collection->truncatePath('/a');

		$this->assertEquals(['1'], $collection->get());
	}

	public function test_setToRelativePath_UnmatchedPath_NotModified()
	{
		$collection = new ResourceCollection();
		$collection->add('/a/1');
		$collection->truncatePath('/b');

		$this->assertEquals(['/a/1'], $collection->get());
	}

	public function test_iteration()
	{
		$expected = ['a', 'b', 'c'];
		$curr = 0;

		$collection = new ResourceCollection();
		$collection->add('a');
		$collection->add('b');
		$collection->add('c');

		foreach ($collection as $value)
		{
			$this->assertEquals($expected[$curr++], $value);
		}

		$this->assertEquals(count($expected), $curr);
	}
}


text:
function PuzzleSymbol(params) {
	this.char = params.char;
	this.packed = params.packed || '';
}
PuzzleSymbol.prototype.toString = function() {
	return this.char + (this.packed.length > 0 ? '(' + this.packed + ')' : '');
};

export default PuzzleSymbol;


text:
// The MIT License (MIT)
//
// Copyright (c) 2014-2016, Institute for Software & Systems Engineering
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

namespace SafetySharp.Modeling
{
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Linq.Expressions;
	using System.Reflection;
	using System.Runtime.CompilerServices;
	using CompilerServices;
	using Runtime;
	using Runtime.Serialization;
	using Utilities;

	/// <summary>
	///   Manages the allowed ranges and overflow behaviors of <see cref="Component" /> fields.
	/// </summary>
	public static class Range
	{
		private static readonly ConditionalWeakTable<object, List<RangeMetadata>> _ranges =
			new ConditionalWeakTable<object, List<RangeMetadata>>();

		/// <summary>
		///   Gets the range metadata for the <paramref name="field" />. Returns <c>null</c> when the range is unrestricted.
		/// </summary>
		/// <param name="field">The field the range metadata should be returned for.</param>
		internal static RangeMetadata GetMetadata(FieldInfo field)
		{
			var range = field.GetCustomAttribute<RangeAttribute>();
			return range == null ? null : RangeMetadata.Create(null, field, range);
		}

		/// <summary>
		///   Gets the range metadata for the <paramref name="obj" />'s <paramref name="field" />. Returns <c>null</c> when the range is
		///   unrestricted.
		/// </summary>
		/// <param name="model">The model that stores the <paramref name="obj" />'s range metadata.</param>
		/// <param name="obj">The object the range metadata should be returned for.</param>
		/// <param name="field">The field the range metadata should be returned for.</param>
		internal static RangeMetadata GetMetadata(ModelBase model, object obj, FieldInfo field)
		{
			// For backing fields of auto-implemented properties, check the property instead
			// TODO: Remove this workaround once C# supports [field:Attribute] on properties
			var range = field.GetCustomAttribute<RangeAttribute>() ?? field?.GetAutoProperty()?.GetCustomAttribute<RangeAttribute>();

			if (range != null)
				return RangeMetadata.Create(obj, field, range);

			var metadata = model.RangeMetadata.FirstOrDefault(m => m.DescribesField(obj, field));
			return metadata ?? CreateDefaultRange(obj, field);
		}

		/// <summary>
		///   Restricts values that can be stored in the field referenced by the <paramref name="fieldExpression" /> to the range of
		///   <paramref name="lowerBound" /> and <paramref name="upperBound" />, both inclusive, using the
		///   <paramref name="overflowBehavior" /> to handle range overflows.
		/// </summary>
		/// <typeparam name="T">The type of the field that is restricted.</typeparam>
		/// <param name="fieldExpression">The expression referencing the field whose range should be restricted.</param>
		/// <param name="lowerBound">The inclusive lower bound.</param>
		/// <param name="upperBound">The inclusive upper bound.</param>
		/// <param name="overflowBehavior">The overflow behavior.</param>
		public static void Restrict<T>([LiftExpression] T fieldExpression, object lowerBound, object upperBound, OverflowBehavior overflowBehavior)
			where T : struct, IComparable
		{
			Requires.CompilationTransformation();
		}

		/// <summary>
		///   Restricts values that can be stored in the field referenced by the <paramref name="fieldExpression" /> to the range of
		///   <paramref name="lowerBound" /> and <paramref name="upperBound" />, both inclusive, using the
		///   <paramref name="overflowBehavior" /> to handle range overflows.
		/// </summary>
		/// <typeparam name="T">The type of the field that is restricted.</typeparam>
		/// <param name="fieldExpression">The expression referencing the field whose range should be restricted.</param>
		/// <param name="lowerBound">The inclusive lower bound.</param>
		/// <param name="upperBound">The inclusive upper bound.</param>
		/// <param name="overflowBehavior">The overflow behavior.</param>
		public static void Restrict<T>(Expression<Func<T>> fieldExpression, object lowerBound, object upperBound,
									   OverflowBehavior overflowBehavior)
			where T : struct, IComparable
		{
			Requires.NotNull(fieldExpression, nameof(fieldExpression));
			Requires.InRange(overflowBehavior, nameof(overflowBehavior));
			Requires.That(typeof(T).IsNumericType(), nameof(fieldExpression), "Expected a field of numeric type.");
			Requires.OfType<MemberExpression>(fieldExpression.Body, nameof(fieldExpression), "Expected a non-nested reference to a field.");

			var range = new RangeAttribute(lowerBound, upperBound, overflowBehavior);
			var memberExpression = (MemberExpression)fieldExpression.Body;
			var propertyInfo = memberExpression.Member as PropertyInfo;
			var fieldInfo = propertyInfo?.GetBackingField() ?? memberExpression.Member as FieldInfo;
			var objectExpression = memberExpression.Expression as ConstantExpression;

			Requires.That(fieldInfo != null, nameof(fieldExpression), "Expected a non-nested reference to a field or an auto-property.");
			Requires.That(objectExpression != null, nameof(fieldExpression), "Expected a non-nested reference to non-static field of primitive type.");
			Requires.That(((IComparable)range.LowerBound).CompareTo(range.UpperBound) <= 0, nameof(lowerBound),
				$"lower bound '{range.LowerBound}' is not smaller than upper bound '{range.UpperBound}'.");

			List<RangeMetadata> fields;
			if (_ranges.TryGetValue(objectExpression.Value, out fields))
			{
				var metadata = fields.FirstOrDefault(m => m.DescribesField(objectExpression.Value, fieldInfo));
				if (metadata != null)
					fields.Remove(metadata);

				fields.Add(RangeMetadata.Create(objectExpression.Value, fieldInfo, range));
			}
			else
				_ranges.Add(objectExpression.Value, new List<RangeMetadata> { RangeMetadata.Create(objectExpression.Value, fieldInfo, range) });
		}

		/// <summary>
		///   Copies the range metadata of the <paramref name="model" />'s object to the <paramref name="model" />.
		/// </summary>
		/// <param name="model">The model whose range metadata should be copied.</param>
		public static void CopyMetadata(ModelBase model)
		{
			foreach (var obj in model.ReferencedObjects)
			{
				List<RangeMetadata> metadata;
				if (_ranges.TryGetValue(obj, out metadata))
					model.RangeMetadata.AddRange(metadata);
			}
		}

		/// <summary>
		///   Creates the default range when no additional range data is available for the <paramref name="obj" />'s
		///   <paramref name="field" />.
		/// </summary>
		internal static RangeMetadata CreateDefaultRange(object obj, FieldInfo field)
		{
			// Check if the serializer knows a range
			RangeAttribute range;
			if (SerializationRegistry.Default.GetSerializer(obj).TryGetRange(obj, field, out range))
				return RangeMetadata.Create(obj, field, range);

			// Otherwise, maybe we can deduce a range for the type
			return RangeMetadata.Create(obj, field, CreateDefaultRange(field.FieldType));
		}

		/// <summary>
		///   Creates the default range when no additional range data is available for the <paramref name="type" />.
		/// </summary>
		internal static RangeAttribute CreateDefaultRange(Type type)
		{
			// We can optimize enums
			if (type.IsEnum)
			{
				var values = ConvertValues(type, Enum.GetValues(type));
				if (values.Length == 0)
					return new RangeAttribute(0, 0, OverflowBehavior.Error);

				if (!type.HasAttribute<FlagsAttribute>())
					return new RangeAttribute(values.Min(), values.Max(), OverflowBehavior.Error);
			}

			// In all other cases, we have to assume that the full range is used
			return null;
		}

		/// <summary>
		///   Converts the <paramref name="values" /> of the <paramref name="enumType" /> to an array of <see cref="object" /> values.
		/// </summary>
		private static object[] ConvertValues(Type enumType, Array values)
		{
			switch (Type.GetTypeCode(enumType.GetEnumUnderlyingType()))
			{
				case TypeCode.SByte:
					return ((sbyte[])values).Cast<object>().ToArray();
				case TypeCode.Byte:
					return ((byte[])values).Cast<object>().ToArray();
				case TypeCode.Int16:
					return ((short[])values).Cast<object>().ToArray();
				case TypeCode.UInt16:
					return ((ushort[])values).Cast<object>().ToArray();
				case TypeCode.Int32:
					return ((int[])values).Cast<object>().ToArray();
				case TypeCode.UInt32:
					return ((uint[])values).Cast<object>().ToArray();
				case TypeCode.Int64:
					return ((long[])values).Cast<object>().ToArray();
				case TypeCode.UInt64:
					return ((ulong[])values).Cast<object>().ToArray();
				default:
					return Assert.NotReached<object[]>("Cannot convert a values.");
			}
		}
	}
}


text:
package net.bluemix.droneselfie;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.paho.client.mqttv3.MqttException;

@WebServlet("/navigate")
public class CommandServlet extends HttpServlet {

	private static final long serialVersionUID = -1623116324694499889L;

	public CommandServlet() {
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		boolean inputok = true;
		String command = request.getParameter("c");
		if (command == null)
			inputok = false;
		if (command.equals(""))
			inputok = false;

		if (inputok == false)
			response.sendError(HttpServletResponse.SC_BAD_REQUEST);
		else {
			try {
				MQTTUtilities.sendMQTTMessage(command, null);
				response.setStatus(HttpServletResponse.SC_OK);
			}
			catch (MqttException me) {
				response.sendError(HttpServletResponse.SC_BAD_REQUEST);
			}
		}

	}

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
	}
}


text:
/*
  Expand a ghost by flattening nested records

  Parameter:
    ghost - array, a single ghost in compact format received from the server

  Returns:
    array, the expanded ghost with a single array of nesting
    equivalent to the given ghost
*/
function expand( ghost ) {
  var
    FIRST_COMMON_FIELD = 4,
    LAST_COMMON_FIELD = 9,
    MAX_NESTING_DEPTH = LAST_COMMON_FIELD - FIRST_COMMON_FIELD + 1,
    depth = 1,
    recordsBefore = ghost.slice(FIRST_COMMON_FIELD),
    recordsAfter,
    i,
    length,
    currentRecord,
    currentRecordLength;

  // In the context of expand(), a value in a common field
  // can only be an integer number or a string; any value
  // with the type of object is thus treated like an array.
  function isArray( value ) {
    return typeof value === "object";
  }

  // for each depth from 1 to 6
  while ( depth <= MAX_NESTING_DEPTH ) {
    recordsAfter = [];

    // for each record at current step of the expansion
    for ( i = 0, length = recordsBefore.length; i < length; i++ ) {
      currentRecord = recordsBefore[i];

      if ( isArray( currentRecord[depth] ) ) {
        // expand nested records
        currentRecordLength = currentRecord.length;
        for ( j = depth; j < currentRecordLength; j++ ) {
          recordsAfter.push(
            currentRecord
              .slice( 0, depth )
              .concat( currentRecord[j] )
          );
        }
      } else {
        // copy record as is
        recordsAfter.push( currentRecord );
      }
    }

    recordsBefore = recordsAfter;
    depth++;
  }

  // copy top-level values followed with expanded records in resulting ghost
  return ghost.slice( 0, FIRST_COMMON_FIELD).concat( recordsAfter );
}


text:
import { connect } from "react-redux";
import { stringify } from "querystring";
import LeaderItem from "../components/leader_item";
import { urlForTaxon, defaultObservationParams } from "../../shared/util";
import { showNewTaxon } from "../actions/taxon";

function mapStateToProps( state ) {
  const leader = Object.assign( {}, state.leaders.topSpecies );
  const props = {
    label: I18n.t( "top_species" ),
    noContent: true,
    iconClassName: "icon-iconic-unknown",
    linkText: I18n.t( "observations" ),
    name: I18n.t( "no_species_observed" ),
    className: "TopSpecies"
  };
  if ( !leader || !leader.taxon ) {
    return props;
  }
  props.noContent = false;
  let imageUrl;
  if ( leader.taxon.defaultPhoto ) {
    imageUrl = leader.taxon.defaultPhoto.photoUrl( "small" );
  } else {
    props.iconClassName = `icon icon-iconic-${leader.taxon.iconicTaxonName( ).toLowerCase( )}`;
  }
  const urlParams = defaultObservationParams( state );
  urlParams.taxon_id = leader.taxon.id;
  return Object.assign( props, {
    name: leader.taxon.preferred_common_name || leader.taxon.name,
    imageUrl,
    linkText: I18n.t( "x_observations_", {
      count: leader.count === 1 ? leader.count : I18n.toNumber( leader.count, { precision: 0 } )
    } ),
    linkUrl: `/observations?${stringify( urlParams )}`,
    url: urlForTaxon( leader.taxon ),
    onClickUrlPayload: { taxon: leader.taxon }
  } );
}

function mapDispatchToProps( dispatch ) {
  return {
    onClickUrl: payload => dispatch( showNewTaxon( payload.taxon ) )
  };
}

const TopSpeciesContainer = connect(
  mapStateToProps,
  mapDispatchToProps
)( LeaderItem );

export default TopSpeciesContainer;


text:
// Copyright 2013-2020 Trimble Inc. All Rights Reserved.

/**
 * @file
 * @brief Interfaces for SUEntitiesRef.
 */
#ifndef SKETCHUP_MODEL_ENTITIES_H_
#define SKETCHUP_MODEL_ENTITIES_H_

#include <SketchUpAPI/geometry.h>
#include <SketchUpAPI/common.h>
#include <SketchUpAPI/unicodestring.h>
#include <SketchUpAPI/model/curve.h>
#include <SketchUpAPI/model/defs.h>

#pragma pack(push, 8)
#ifdef __cplusplus
extern "C" {
#endif

/**
@struct SUEntitiesRef
@brief References a container object for all entities in a model,
       component definition or a group.
*/

/**
@brief Removes all entities in the container.
@since SketchUp 2019, API 7.0
@param[in] entities The entities to clear.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
*/
SU_RESULT SUEntitiesClear(SUEntitiesRef entities);

/**
@brief SUEntitiesFill is the fastest way to populate an entities object. The
       important precondition is that no duplicate data should be given.

NOTE: Faces included in the geometry input object will be merged together when
  using this function. This only applies to geometry in the geometry input
  object and not to any already-existing geometry in the entities object.
  Examples of merging are:
- If weld_vertices is true, duplicated vertices are merged.
- Coincident faces are merged.
- Coincident faces with opposite normals are merged into a single face using the
  appropriate materials from both faces as the front and back materials.
- Faces are created from coplanar edge loops.
- Conincident edges are merged. Visibility is retained when visible and
  invisible edges are welded together. Hardness is retained when hard and soft
  edges are welded together.

@param[in] entities      The entities to populate. Must be an empty entities
                         object.
@param[in] geom_input    The geometry input that the entities object is to be
                         populated with.
@param[in] weld_vertices Flag indicating whether to join coincident vertices.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities or geom_input are invalid objects
*/
SU_RESULT SUEntitiesFill(SUEntitiesRef entities,
                         SUGeometryInputRef geom_input,
                         bool weld_vertices);

/**
@brief Retrieves the bounding box of the entities.
@param[in]  entities The entities object.
@param[out] bbox     The bounding box retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if bbox is NULL
*/
SU_RESULT SUEntitiesGetBoundingBox(SUEntitiesRef entities,
                                   struct SUBoundingBox3D* bbox);

/**
@brief Retrieves the LLA coordinates (Latidue, Longitude and Altitude) bounding
       box of the given entities object.
       Note that the altitude is calculated based on the model origin, Example:
       If an entities object has a bounding box with the following values
       {{100,100,100}, {200,200,200}} the result will be something like the
       following: {{Latitude, Longitude, 100/METERS_TO_INCHES},
       {Latitude, Longitude, 200/METERS_TO_INCHES}} where Latitude and Longitude
       are the geographical coordinates and altitude is just a conversion from
       inches to meters.
@since SketchUp 2018 M0, API 6.0
@param[in]  entities The entities object.
@param[out] bbox     The latidue longitude and altitude bounding box retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NO_DATA if entities doesn't belong to a valid model.
- \ref SU_ERROR_NULL_POINTER_OUTPUT if bbox is NULL
*/
SU_RESULT SUEntitiesGetBoundingBoxLLA(SUEntitiesRef entities,
                                      struct SUBoundingBox3D* bbox);

/**
@brief Retrieves the number of faces in the entities object.
@param[in] entities The entities object.
@param[out] count   The number of faces.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumFaces(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the faces in the entities object.
@param[in]  entities The entities object.
@param[in]  len      The number of faces to retrieve.
@param[out] faces    The faces retrieved.
@param[out] count    The number of faces retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if faces or count is NULL
*/
SU_RESULT SUEntitiesGetFaces(SUEntitiesRef entities,
                             size_t len,
                             SUFaceRef faces[],
                             size_t*  count);

/**
@brief Retrieves the number of curves in the entities object that are not
       associated with a face.
@param[in]  entities The entities object.
@param[out] count    The number of curves.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumCurves(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the curves in the entities object that are not associated with
       a face.
@param[in]  entities The entities object.
@param[in]  len      The number of curves to retrieve.
@param[out] curves   The curves retrieved.
@param[out] count    The number of curves retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if curves or count is NULL
*/
SU_RESULT SUEntitiesGetCurves(SUEntitiesRef entities,
                              size_t len,
                              SUCurveRef curves[],
                              size_t* count);

/**
@brief Retrieves the number of arccurves in the entities object that are not
       associated with a face.
@since SketchUp 2016, API 4.0
@param[in]  entities The entities object.
@param[out] count    The number of arccurves.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumArcCurves(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the arccurves in the entities object that are not associated
       with a face.
@since SketchUp 2016, API 4.0
@param[in]  entities    The entities object.
@param[in]  len         The number of arccurves to retrieve.
@param[out] arccurves   The arccurves retrieved.
@param[out] count       The number of curves retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if arccurves or count is NULL
*/
SU_RESULT SUEntitiesGetArcCurves(SUEntitiesRef entities,
                                 size_t len,
                                 SUArcCurveRef arccurves[],
                                 size_t* count);

/**
@brief Retrieves the number of guide points in the entities object.
@since SketchUp 2014 M1, API 2.1
@param[in]  entities The entities object.
@param[out] count    The number of guide_points.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumGuidePoints(SUEntitiesRef entities,
                                      size_t* count);

/**
@brief Retrieves the guide points in the entities object.
@since SketchUp 2014 M1, API 2.1
@param[in]  entities     The entities object.
@param[in]  len          The number of guide points to retrieve.
@param[out] guide_points The guide_points retrieved.
@param[out] count        The number of guide_points retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if guide_points or count is NULL
*/
SU_RESULT SUEntitiesGetGuidePoints(SUEntitiesRef entities,
                                   size_t len,
                                   SUGuidePointRef guide_points[],
                                   size_t* count);

/**
@brief Retrieves the number of guide lines in the entities object.
@since SketchUp 2016, API 4.0
@param[in]  entities The entities object.
@param[out] count    The number of guide_lines.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumGuideLines(SUEntitiesRef entities,
                                     size_t* count);

/**
@brief Retrieves the guide lines in the entities object.
@since SketchUp 2016, API 4.0
@param[in]  entities    The entities object.
@param[in]  len         The number of guide lines to retrieve.
@param[out] guide_lines The guide_lines retrieved.
@param[out] count       The number of guide_lines retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if guide_lines or count is NULL
*/
SU_RESULT SUEntitiesGetGuideLines(SUEntitiesRef entities,
                                   size_t len,
                                   SUGuideLineRef guide_lines[],
                                   size_t* count);

/**
@brief Retrieves the number of edges in the entities object.
@param[in]  entities        The entities object.
@param[in]  standalone_only Whether to count all edges (false) or only the edges
                            not attached to curves and faces (true).
@param[out] count           The number of edges.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumEdges(SUEntitiesRef entities,
                                bool standalone_only,
                                size_t* count);

/**
@brief Retrieves the edges in the entities object.
@param[in]  entities        The entities object.
@param[in]  standalone_only Whether to get all edges (false) or only the edges
                            not attached to curves and faces (true).
@param[in]  len             The number of edges to retrieve.
@param[out] edges           The edges retrieved.
@param[out] count           The number of edges retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if edges or count is NULL
*/
SU_RESULT SUEntitiesGetEdges(SUEntitiesRef entities,
                             bool standalone_only, size_t len,
                             SUEdgeRef edges[], size_t* count);

/**
@brief Retrieves the number of polyline3d's in the entities object.
@param[in]  entities The entities object.
@param[out] count    The the number of polyline3d's.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumPolyline3ds(SUEntitiesRef entities,
                                      size_t* count);

/**
@brief Retrieves the polyline3d's in the entities object.
@param[in]  len      The number of polyline3d's to retrieve.
@param[in]  entities The entities object.
@param[out] lines    The polyline3d's retrieved.
@param[out] count    The number of polyline3d's retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if lines or count is NULL
*/
SU_RESULT SUEntitiesGetPolyline3ds(SUEntitiesRef entities,
                                   size_t len,
                                   SUPolyline3dRef lines[],
                                   size_t* count);

/**
@brief Adds face objects to a entities object.

NOTE: This function does not merge geometry, which will likely create an invalid
SketchUp model. It is recommended to use SUGeometryInput instead which does
correctly merge geometry.

@param[in] entities The entities object.
@param[in] len      The length of the array of face objects.
@param[in] faces    The array of face objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if faces is NULL
*/
SU_RESULT SUEntitiesAddFaces(SUEntitiesRef entities,
                             size_t len,
                             const SUFaceRef faces[]);

/**
@brief Adds edge objects to an entities object.

NOTE: This function does not merge geometry, which will likely create an invalid
SketchUp model. It is recommended to use SUGeometryInput instead which does
correctly merge geometry.

@param[in] entities The entities object.
@param[in] len      The length of the array of edge objects.
@param[in] edges    The array of edge objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if edges is NULL
*/
SU_RESULT SUEntitiesAddEdges(SUEntitiesRef entities,
                             size_t len,
                             const SUEdgeRef edges[]);

/**
@brief Adds curve objects to an entities object.

NOTE: This function does not merge geometry, which will likely create an invalid
SketchUp model. It is recommended to use SUGeometryInput instead which does
correctly merge geometry.

@param[in] entities The entities object.
@param[in] len      The length of the array of curve objects.
@param[in] curves   The array of curve objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if curves is NULL
*/
SU_RESULT SUEntitiesAddCurves(SUEntitiesRef entities,
                              size_t len,
                              const SUCurveRef curves[]);

/**
@brief Adds arccurve objects to an entities object.
@since SketchUp 2016, API 4.0

NOTE: This function does not merge geometry, which will likely create an invalid
SketchUp model. It is recommended to use SUGeometryInput instead which does
correctly merge geometry.

@param[in] entities The entities object.
@param[in] len      The length of the array of curve objects.
@param[in] curves   The array of arccurve objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if curves is NULL
*/
SU_RESULT SUEntitiesAddArcCurves(SUEntitiesRef entities,
                                 size_t len,
                                 const SUArcCurveRef curves[]);

/**
@brief Adds guide point objects to an entities object.
@since SketchUp 2014 M1, API 2.1
@param[in] entities     The entities object.
@param[in] len          The length of the array of guide point objects.
@param[in] guide_points The array of guide point objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if guide_points is NULL
*/
SU_RESULT SUEntitiesAddGuidePoints(SUEntitiesRef entities, size_t len,
    const SUGuidePointRef guide_points[]);

/**
@brief Adds guide line objects to an entities object.
@since SketchUp 2016, API 4.0
@param[in] entities    The entities object.
@param[in] len         The length of the array of guide line objects.
@param[in] guide_lines The array of guide line objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if guide_lines is NULL
*/
SU_RESULT SUEntitiesAddGuideLines(SUEntitiesRef entities, size_t len,
                                   const SUGuideLineRef guide_lines[]);

/**
@brief Adds a group object to an entities object.
@param[in] entities The entities object.
@param[in] group    The group object to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities or group is not a valid object
*/
SU_RESULT SUEntitiesAddGroup(SUEntitiesRef entities, SUGroupRef group);

/**
@brief Adds an image object to an entities object.
@param[in] entities The entities object.
@param[in] image    The image object to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities or image is not a valid object
*/
SU_RESULT SUEntitiesAddImage(SUEntitiesRef entities, SUImageRef image);

/**
@brief Adds a component instance object to the entities.
@param[in]  entities The entities object.
@param[in]  instance The component instance object to add.
@param[out] name     The unique name that is assigned to definition of the
                     component instance. This can be NULL in which case the
                     caller does not need to retrieve the assigned name.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities or instance is not a valid object
- \ref SU_ERROR_INVALID_OUTPUT if name (when not NULL) does not refer to a valid
  \ref SUStringRef object
*/
SU_RESULT SUEntitiesAddInstance(SUEntitiesRef entities,
                                SUComponentInstanceRef instance,
                                SUStringRef* name);

/**
@brief Adds section plane objects to an entities object.
@since SketchUp 2016, API 4.0
@param[in] entities        The entities object.
@param[in] len             The length of the array of section planes objects.
@param[in] section_planes  The array of section planes objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if section_planes is NULL
*/
SU_RESULT SUEntitiesAddSectionPlanes(SUEntitiesRef entities,
                                     size_t len,
                                     const SUSectionPlaneRef section_planes[]);

/**
@brief Adds text objects to an entities object.
@since SketchUp 2018, API 6.0
@param[in] entities The entities object.
@param[in] len      The length of the array of text objects.
@param[in] texts    The array of text objects to add.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if texts is NULL
*/
SU_RESULT SUEntitiesAddTexts(SUEntitiesRef entities, size_t len,
                             const SUTextRef texts[]);

/**
@brief Retrieves the number of groups in the entities.
@param[in]  entities The entities object.
@param[out] count    The number of groups.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is an invalid entities object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumGroups(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the groups in the entities.
@param[in]  entities The entities object.
@param[in]  len      The number of groups to retrieve.
@param[out] groups   The groups retrieved.
@param[out] count    The number of groups retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if groups or count is NULL
*/
SU_RESULT SUEntitiesGetGroups(SUEntitiesRef entities,
                              size_t len,
                              SUGroupRef groups[],
                              size_t* count);

/**
@brief Retrieves the number of images in the entities.
@param[in]  entities  The entities object.
@param[out] count     The number of image objects.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumImages(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the array of image objects of a entities object.
@param[in]  entities The entities object.
@param[in]  len      The number of image objects to retrieve.
@param[out] images   The image objects retrieved.
@param[out] count    The number of image objects retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if images or count is NULL
*/
SU_RESULT SUEntitiesGetImages(SUEntitiesRef entities,
                              size_t len,
                              SUImageRef images[],
                              size_t* count);

/**
@brief Retrieves the number of component instances in the entities.
@param[in] entities The entities object.
@param[out] count   The number of component instances.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is an invalid entities object.
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumInstances(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the component instances in the entities.
@param[in]  entities  The entities object.
@param[in]  len       The number of component instances to retrieve.
@param[out] instances The component instances retrieved.
@param[out] count     The number of component instances retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if instances or count is NULL
*/
SU_RESULT SUEntitiesGetInstances(SUEntitiesRef entities,
                                 size_t len,
                                 SUComponentInstanceRef instances[],
                                 size_t* count);

/**
@brief Retrieves the number of section planes in the entities object.
@since SketchUp 2016, API 4.0
@param[in]  entities The entities object.
@param[out] count    The number of section planes.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumSectionPlanes(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the number of texts in the entities object.
@since SketchUp 2018, API 6.0
@param[in]  entities The entities object.
@param[out] count    The number of texts.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumTexts(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the section planes in the entities.
@since SketchUp 2016, API 4.0
@param[in]  entities       The entities object.
@param[in]  len            The number of section planes to retrieve.
@param[out] section_planes The section planes retrieved.
@param[out] count          The number of section planes retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if section_planes or count is NULL
*/
SU_RESULT SUEntitiesGetSectionPlanes(SUEntitiesRef entities,
                                     size_t len,
                                     SUSectionPlaneRef section_planes[],
                                     size_t* count);

/**
@brief Retrieves the number of dimensions in the entities object.
@since SketchUp 2017, API 5.0
@param[in]  entities The entities object.
@param[out] count    The number of dimensions.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if count is NULL
*/
SU_RESULT SUEntitiesGetNumDimensions(SUEntitiesRef entities, size_t* count);

/**
@brief Retrieves the dimensions in the entities object.
@since SketchUp 2017, API 5.0
@param[in]  entities   The entities object.
@param[in]  len        The number of dimensions to retrieve.
@param[out] dimensions The dimensions retrieved.
@param[out] count      The number of dimensions retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if dimensions or count is NULL
*/
SU_RESULT SUEntitiesGetDimensions(SUEntitiesRef entities, size_t len,
    SUDimensionRef* dimensions, size_t* count);

/**
@brief Retrieves the texts in the entities.
@since SketchUp 2018, API 6.0
@param[in]  entities The entities object.
@param[in]  len      The number of section planes to retrieve.
@param[out] texts    The texts retrieved.
@param[out] count    The number of texts retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_OUTPUT if texts or count is NULL
*/
SU_RESULT SUEntitiesGetTexts(SUEntitiesRef entities, size_t len,
                             SUTextRef texts[], size_t* count);

/**
@brief Applies a 3D transformation to the elements of the provided entity array.
@since SketchUp 2017, API 5.0
@param[in] entities The entities object.
@param[in] len      The number of entities in the array.
@param[in] elements The elements to be transformed.
@param[in] trans    The transform to be applied.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if trans or elements are NULL
- \ref SU_ERROR_UNSUPPORTED if any of the elements in the array are not
       contained by entities
- \ref SU_ERROR_GENERIC if the transformation operation fails
*/
SU_RESULT SUEntitiesTransform(SUEntitiesRef entities, size_t len,
    SUEntityRef elements[], const struct SUTransformation* trans);

/**
@brief Applies a 3D transformations to the elements of the provided entity
       array. The arrays of elements and transformations must be the same
       length.
@since SketchUp 2017, API 5.0
@param[in] entities  The entities object.
@param[in] len       The number of entities in the array.
@param[in] elements  The elements to be transformed.
@param[in] tranforms The transformations to be applied.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if elements or tranforms are NULL
- \ref SU_ERROR_UNSUPPORTED if any of the elements in the array are not
       contained by entities
- \ref SU_ERROR_GENERIC if the transformation operation fails
*/
SU_RESULT SUEntitiesTransformMultiple(SUEntitiesRef entities, size_t len,
    SUEntityRef elements[], const struct SUTransformation tranforms[]);

/**
@brief Erases elements from an entities object. The input elements are
       destroyed, so the array elements are invalidated to prevent user from
       attempting to use destroyed entities.
@since SketchUp 2017, API 5.0
@param[in] entities The entities object.
@param[in] len      The number of entities in the array.
@param[in] elements The elements to be destroyed.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if elements is NULL
- \ref SU_ERROR_UNSUPPORTED if any of the elements in the array are not
       contained by entities
*/
SU_RESULT SUEntitiesErase(SUEntitiesRef entities, size_t len,
    SUEntityRef elements[]);

/**
@brief Retrieves a boolean indicating whether the entities object is
       recursively empty. A recursively empty entities object is defined as one
       that either has zero entities or contains only instances of definitions
       with recursively empty entities objects.
@since SketchUp 2017, API 5.0
@param[in]  entities The entities object.
@param[out] is_empty The bool value retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is invalid
- \ref SU_ERROR_NULL_POINTER_OUTPUT if is_empty is NULL
*/
SU_RESULT SUEntitiesIsRecursivelyEmpty(SUEntitiesRef entities, bool* is_empty);

/**
@brief Retrieves a boolean by recursively searching through the entities
       determining whether the entities has an active section plane or any
       of its nested components have an active section plane.
@since SketchUp 2018, API 6.0
@param[in]  entities          The entities object.
@param[out] has_section_cuts  The bool value retrieved.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is invalid
- \ref SU_ERROR_NULL_POINTER_OUTPUT if has_section_cuts is NULL
*/
SU_RESULT SUEntitiesHasSectionCuts(SUEntitiesRef entities,
                                   bool* has_section_cuts);

/**
@brief Fills the list with all entities of the specified type in the instance.
       The list is not in any specific order.
@since SketchUp 2018, API 6.0
@param[in]  entities The entities object to be queried.
@param[in]  type     The type of entities to be collected.
@param[out] list     The list object to be filled.
@related SUEntitiesRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_INVALID_OUTPUT if list is not a valid object
*/
SU_RESULT SUEntitiesEntityListFill(SUEntitiesRef entities,
    enum SURefType type, SUEntityListRef list);

/**
@brief Takes a set of edges and find all possible chains of edges and connect
       them with a \ref SUCurveRef.

       A curve will not cross another curve. They will split where multiple
       curves meet.

@since SketchUp 2020.1, API 8.1
@param[in]  entities   The entities object to be queried.
@param[in]  num_edges  The length of the array of edge objects.
@param[in]  edges      The array of edge objects to weld.
@param[out] list       The list object to be filled with \ref SUCurveRef objects.
@related SUEntitiesRef
@see SUArcCurveRef
@see SUCurveRef
@return
- \ref SU_ERROR_NONE on success
- \ref SU_ERROR_INVALID_INPUT if entities is not a valid object
- \ref SU_ERROR_NULL_POINTER_INPUT if edges is NULL
- \ref SU_ERROR_INVALID_OUTPUT if list is not a valid object
- \ref SU_ERROR_INVALID_ARGUMENT if edges contains edges that don't belong to
         the same entities collection.
*/
SU_RESULT SUEntitiesWeld(SUEntitiesRef entities, size_t num_edges,
    SUEdgeRef edges[], SUEntityListRef list);

#ifdef __cplusplus
}  // extern "C"
#endif
#pragma pack(pop)

#endif  // SKETCHUP_MODEL_ENTITIES_H_


text:
package com.cws.esolutions.security.config.xml;
/*
 * Project: eSolutionsSecurity
 * Package: com.cws.esolutions.security.config.xml
 * File: RepositoryConfig.java
 *
 * History
 *
 * Author               Date                            Comments
 * ----------------------------------------------------------------------------
 * cws-khuntly          11/23/2008 22:39:20             Created.
 */
import java.util.List;
import org.slf4j.Logger;
import java.io.Serializable;
import java.lang.reflect.Field;
import org.slf4j.LoggerFactory;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElementWrapper;

import com.cws.esolutions.security.SecurityServiceConstants;
/**
 * @author cws-khuntly
 * @version 1.0
 * @see java.io.Serializable
 */
@XmlType(name = "userReturningAttributes")
@XmlAccessorType(XmlAccessType.NONE)
public final class UserReturningAttributes implements Serializable
{
    private int lockCount = 0;
    private String userId = null;
    private String surname = null;
    private String userGuid = null;
    private String memberOf = null;
    private String emailAddr = null;
    private String givenName = null;
    private Long lastLoginDate = -1L;
    private String commonName = null;
    private String displayName = null;
    private String telephoneNumber = null;
    private List<String> returningAttributes = null;

    private static final long serialVersionUID = -4767557511096921048L;
    private static final String CNAME = UserReturningAttributes.class.getName();

    private static final Logger DEBUGGER = LoggerFactory.getLogger(SecurityServiceConstants.DEBUGGER);
    private static final boolean DEBUG = DEBUGGER.isDebugEnabled();
    private static final Logger ERROR_RECORDER = LoggerFactory.getLogger(SecurityServiceConstants.ERROR_LOGGER);

    public final void setCommonName(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setCommonName(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.commonName = value;
    }

    public final void setUserId(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setUserId(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.userId = value;
    }

    public final void setUserGuid(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setUserGuid(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.userGuid = value;
    }

    public final void setSurname(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setSurname(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.surname = value;
    }

    public final void setGivenName(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setGivenName(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.givenName = value;
    }

    public final void setDisplayName(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setDisplayName(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.displayName = value;
    }

    public final void setEmailAddr(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setEmailAddr(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.emailAddr = value;
    }

    public final void setTelephoneNumber(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setTelephoneNumber(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.telephoneNumber = value;
    }

    public final void setMemberOf(final String value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setMemberOf(final String value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.memberOf = value;
    }

    public final void setReturningAttributes(final List<String> value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setReturningAttributes(final List<String> value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.returningAttributes = value;
    }

    public final void setLastLoginDate(final Long value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setLastLoginDate(final Long value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.lastLoginDate = value;
    }

    public final void setLockCount(final int value)
    {
        final String methodName = UserReturningAttributes.CNAME + "#setLockCount(final int value)";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", value);
        }

        this.lockCount = value;
    }

    @XmlElement(name = "commonName")
    public final String getCommonName()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getCommonName()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.commonName);
        }

        return this.commonName;
    }

    @XmlElement(name = "userGuid")
    public final String getUserGuid()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getUserGuid()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.userGuid);
        }

        return this.userGuid;
    }

    @XmlElement(name = "cwslastlogin")
    public final Long getLastLoginDate()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getLastLoginDate()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.lastLoginDate);
        }

        return this.lastLoginDate;
    }

    @XmlElement(name = "cwslastlogin")
    public final int getLockCount()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getLockCount()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.lockCount);
        }

        return this.lockCount;
    }

    @XmlElement(name = "userId")
    public final String getUserId()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getUserId()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.userId);
        }

        return this.userId;
    }

    @XmlElement(name = "surname")
    public final String getSurname()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getSurname()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.surname);
        }

        return this.surname;
    }

    @XmlElement(name = "givenName")
    public final String getGivenName()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getGivenName()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.givenName);
        }

        return this.givenName;
    }

    @XmlElement(name = "displayName")
    public final String getDisplayName()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getDisplayName()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.displayName);
        }

        return this.displayName;
    }

    @XmlElement(name = "emailAddr")
    public final String getEmailAddr()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getEmailAddr()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.emailAddr);
        }

        return this.emailAddr;
    }

    @XmlElement(name = "telephoneNumber")
    public final String getTelephoneNumber()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getTelephoneNumber()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.telephoneNumber);
        }

        return this.telephoneNumber;
    }

    @XmlElement(name = "memberOf")
    public final String getMemberOf()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getTcAccepted()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.memberOf);
        }

        return this.memberOf;
    }

    @XmlElement(name = "attributeName")
    @XmlElementWrapper(name = "returningAttributes")
    public final List<String> getReturningAttributes()
    {
        final String methodName = UserReturningAttributes.CNAME + "#getReturningAttributes()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
            DEBUGGER.debug("Value: {}", this.returningAttributes);
        }

        return this.returningAttributes;
    }

    @Override
    public final String toString()
    {
        final String methodName = UserReturningAttributes.CNAME + "#toString()";

        if (DEBUG)
        {
            DEBUGGER.debug(methodName);
        }

        StringBuilder sBuilder = new StringBuilder()
            .append("[" + this.getClass().getName() + "]" + SecurityServiceConstants.LINE_BREAK + "{" + SecurityServiceConstants.LINE_BREAK);

        for (Field field : this.getClass().getDeclaredFields())
        {
            if (DEBUG)
            {
                DEBUGGER.debug("field: {}", field);
            }

            if (!(field.getName().equals("methodName")) &&
                    (!(field.getName().equals("CNAME"))) &&
                    (!(field.getName().equals("DEBUGGER"))) &&
                    (!(field.getName().equals("DEBUG"))) &&
                    (!(field.getName().equals("ERROR_RECORDER"))) &&
                    (!(field.getName().equals("serialVersionUID"))))
            {
                try
                {
                    if (field.get(this) != null)
                    {
                        sBuilder.append("\t" + field.getName() + " --> " + field.get(this) + SecurityServiceConstants.LINE_BREAK);
                    }
                }
                catch (IllegalAccessException iax)
                {
                    ERROR_RECORDER.error(iax.getMessage(), iax);
                }
            }
        }

        sBuilder.append('}');

        if (DEBUG)
        {
            DEBUGGER.debug("sBuilder: {}", sBuilder);
        }

        return sBuilder.toString();
    }
}


text:
using System;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.CodeActions;
using Analyzer.Utilities;
using System.Composition;
using System.Collections.Generic;
using Analyzer.Utilities.Extensions;

namespace Microsoft.CodeQuality.Analyzers.ApiDesignGuidelines
{
    /// <summary>
    /// CA1032: Implement standard exception constructors
    /// Cause: A type extends System.Exception and does not declare all the required constructors.
    /// Description: Exception types must implement the following constructors. Failure to provide the full set of constructors can make it difficult to correctly handle exceptions
    /// For CSharp, all possible  missing Constructors would be
    ///     public GoodException()
    ///     public GoodException(string)
    ///     public GoodException(string, Exception)
    /// For Basic, all possible  missing Constructors would be
    ///     Sub New()
    ///     Sub New(message As String)
    ///     Sub New(message As String, innerException As Exception)
    /// </summary>
    [ExportCodeFixProvider(LanguageNames.CSharp, LanguageNames.VisualBasic), Shared]
    public sealed class ImplementStandardExceptionConstructorsFixer : CodeFixProvider
    {
        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(ImplementStandardExceptionConstructorsAnalyzer.RuleId);

        public sealed override FixAllProvider GetFixAllProvider()
        {
            // Fixes all occurrences within within Document, Project, or Solution
            return WellKnownFixAllProviders.BatchFixer;
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            string title = MicrosoftCodeQualityAnalyzersResources.ImplementStandardExceptionConstructorsTitle;

            // Get syntax root node
            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);

            // Register fixer - pass in the collection of diagnostics, since there could be more than one for this diagnostic due to more than one of the required constructors missing
            context.RegisterCodeFix(CodeAction.Create(title, c => AddConstructorsAsync(context.Document, context.Diagnostics, root, c), equivalenceKey: title), context.Diagnostics.First());
        }

        private static async Task<Document> AddConstructorsAsync(Document document, IEnumerable<Diagnostic> diagnostics, SyntaxNode root, CancellationToken cancellationToken)
        {
            DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
            SyntaxGenerator generator = editor.Generator;
            SemanticModel model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            CodeAnalysis.Text.TextSpan diagnosticSpan = diagnostics.First().Location.SourceSpan; // All the diagnostics are reported at the same location -- the name of the declared class -- so it doesn't matter which one we pick
            SyntaxNode node = root.FindNode(diagnosticSpan);
            SyntaxNode targetNode = editor.Generator.GetDeclaration(node, DeclarationKind.Class);
            if (model.GetDeclaredSymbol(targetNode, cancellationToken) is not INamedTypeSymbol typeSymbol)
            {
                return document;
            }

            foreach (Diagnostic diagnostic in diagnostics)
            {
                var missingCtorSignature = (ImplementStandardExceptionConstructorsAnalyzer.MissingCtorSignature)Enum.Parse(typeof(ImplementStandardExceptionConstructorsAnalyzer.MissingCtorSignature), diagnostic.Properties["Signature"]);

                switch (missingCtorSignature)
                {
                    case ImplementStandardExceptionConstructorsAnalyzer.MissingCtorSignature.CtorWithNoParameter:
                        // Add missing CtorWithNoParameter
                        SyntaxNode newConstructorNode1 = generator.ConstructorDeclaration(typeSymbol.Name, accessibility: Accessibility.Public);
                        editor.AddMember(targetNode, newConstructorNode1);
                        break;
                    case ImplementStandardExceptionConstructorsAnalyzer.MissingCtorSignature.CtorWithStringParameter:
                        // Add missing CtorWithStringParameter
                        SyntaxNode newConstructorNode2 = generator.ConstructorDeclaration(
                                                    containingTypeName: typeSymbol.Name,
                                                    parameters: new[]
                                                    {
                                                    generator.ParameterDeclaration("message", generator.TypeExpression(editor.SemanticModel.Compilation.GetSpecialType(SpecialType.System_String)))
                                                    },
                                                    accessibility: Accessibility.Public,
                                                    baseConstructorArguments: new[]
                                                    {
                                                    generator.Argument(generator.IdentifierName("message"))
                                                    });
                        editor.AddMember(targetNode, newConstructorNode2);
                        break;
                    case ImplementStandardExceptionConstructorsAnalyzer.MissingCtorSignature.CtorWithStringAndExceptionParameters:
                        // Add missing CtorWithStringAndExceptionParameters
                        SyntaxNode newConstructorNode3 = generator.ConstructorDeclaration(
                                                    containingTypeName: typeSymbol.Name,
                                                    parameters: new[]
                                                    {
                                                    generator.ParameterDeclaration("message", generator.TypeExpression(editor.SemanticModel.Compilation.GetSpecialType(SpecialType.System_String))),
                                                    generator.ParameterDeclaration("innerException", generator.TypeExpression(editor.SemanticModel.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemException)))
                                                    },
                                                    accessibility: Accessibility.Public,
                                                    baseConstructorArguments: new[]
                                                    {
                                                    generator.Argument(generator.IdentifierName("message")),
                                                    generator.Argument(generator.IdentifierName("innerException"))
                                                    });
                        editor.AddMember(targetNode, newConstructorNode3);
                        break;
                }
            }

            return editor.GetChangedDocument();
        }
    }
}


text:
package us.nineworlds.xstreamer.ia.lookup;

import java.util.List;

import us.nineworlds.xstreamer.ia.model.maps.MapMetaData;
import us.nineworlds.xstreamer.ia.model.maps.Maps;

public class SkirmishMapsLookup {

   private static SkirmishMapsLookup instance;

   private List<MapMetaData> mapsMetaData;

   public static SkirmishMapsLookup newInstance(Maps commandCardDB) {
      instance = new SkirmishMapsLookup(commandCardDB);
      return instance;
   }

   public static SkirmishMapsLookup getInstance() {
      return instance;
   }

   private SkirmishMapsLookup(Maps maps) {
      this.mapsMetaData = maps.getMaps();
   }

   public MapMetaData findMap(String mapName) {
      for(MapMetaData map : mapsMetaData) {
    	  if (map.getName().equals(mapName)) {
    		  return map;
    	  }
      }
      return null;
   }

   public List<MapMetaData> getMaps() {
	   return mapsMetaData;
   }
}


text:
package org.lemsml.jlems.core.codger.metaclass;

public abstract class AbstractExpression {

	public abstract String generateJava();

}


text:
class ActivityController < ApplicationController
  def remove_activity
    params.permit(:id)
    RailsNewsfeed::Activity.delete(id: params[:id])
    render nothing: true
  end
end


text:
namespace CryptoNote {

class WalletLegacyObserver: public IWalletLegacyObserver {
public:

  WalletLegacyObserver() :
    m_actualBalance(0),
    m_actualBalancePrev(0),
    m_pendingBalance(0),
    m_pendingBalancePrev(0),
    m_syncResult(m_mutex, m_cv) {}

  virtual void actualBalanceUpdated(uint64_t actualBalance) override {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_actualBalance = actualBalance;
    lk.unlock();
    m_cv.notify_all();
  }

  virtual void pendingBalanceUpdated(uint64_t pendingBalance) override {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_pendingBalance = pendingBalance;
    lk.unlock();
    m_cv.notify_all();
  }

  virtual void sendTransactionCompleted(CryptoNote::TransactionId transactionId, std::error_code result) override {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_sendResults[transactionId] = result;
    m_cv.notify_all();
  }

  virtual void synchronizationCompleted(std::error_code result) override {
    m_syncResult.set(result);
  }

  virtual void synchronizationProgressUpdated(uint32_t current, uint32_t total) override {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_syncProgress.emplace_back(current, total);
    m_currentHeight = current;
    m_cv.notify_all();
  }

  virtual void externalTransactionCreated(TransactionId transactionId) override {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_externalTransactions.push_back(transactionId);
    m_cv.notify_all();
  }

  uint64_t getCurrentHeight() {
    std::unique_lock<std::mutex> lk(m_mutex);
    return m_currentHeight;
  }

  uint64_t waitPendingBalanceChange() {
    std::unique_lock<std::mutex> lk(m_mutex);
    while (m_pendingBalance == m_pendingBalancePrev) {
      m_cv.wait(lk);
    }
    m_pendingBalancePrev = m_pendingBalance;
    return m_pendingBalance;
  }

  uint64_t waitTotalBalanceChange() {
    std::unique_lock<std::mutex> lk(m_mutex);
    while (m_pendingBalance == m_pendingBalancePrev && m_actualBalance == m_actualBalancePrev) {
      m_cv.wait(lk);
    }

    m_actualBalancePrev = m_actualBalance;
    m_pendingBalancePrev = m_pendingBalance;

    return m_actualBalance + m_pendingBalance;
  }

  CryptoNote::TransactionId waitExternalTransaction() {
    std::unique_lock<std::mutex> lk(m_mutex);

    while (m_externalTransactions.empty()) {
      m_cv.wait(lk);
    }

    CryptoNote::TransactionId txId = m_externalTransactions.front();
    m_externalTransactions.pop_front();
    return txId;
  }

  template<class Rep, class Period>
  std::pair<bool, uint64_t> waitPendingBalanceChangeFor(const std::chrono::duration<Rep, Period>& timePeriod) {
    std::unique_lock<std::mutex> lk(m_mutex);
    bool result = m_cv.wait_for(lk, timePeriod, [&] { return m_pendingBalance != m_pendingBalancePrev; });
    m_pendingBalancePrev = m_pendingBalance;
    return std::make_pair(result, m_pendingBalance);
  }

  uint64_t waitActualBalanceChange() {
    std::unique_lock<std::mutex> lk(m_mutex);
    while (m_actualBalance == m_actualBalancePrev) {
      m_cv.wait(lk);
    }
    m_actualBalancePrev = m_actualBalance;
    return m_actualBalance;
  }

  std::error_code waitSendResult(CryptoNote::TransactionId txid) {
    std::unique_lock<std::mutex> lk(m_mutex);

    std::unordered_map<CryptoNote::TransactionId, std::error_code>::iterator it;

    while ((it = m_sendResults.find(txid)) == m_sendResults.end()) {
      m_cv.wait(lk);
    }

    return it->second;
  }

  uint64_t totalBalance() {
    std::unique_lock<std::mutex> lk(m_mutex);
    m_pendingBalancePrev = m_pendingBalance;
    m_actualBalancePrev = m_actualBalance;
    return m_pendingBalance + m_actualBalance;
  }

  std::vector<std::pair<uint32_t, uint32_t>> getSyncProgress() {
    std::unique_lock<std::mutex> lk(m_mutex);
    return m_syncProgress;
  }

  ObservableValueBase<std::error_code> m_syncResult;

private:

  std::mutex m_mutex;
  std::condition_variable m_cv;

  uint64_t m_actualBalance;
  uint64_t m_actualBalancePrev;
  uint64_t m_pendingBalance;
  uint64_t m_pendingBalancePrev;

  uint32_t m_currentHeight;

  std::vector<std::pair<uint32_t, uint32_t>> m_syncProgress;

  std::unordered_map<CryptoNote::TransactionId, std::error_code> m_sendResults;
  std::deque<CryptoNote::TransactionId> m_externalTransactions;
};

}


text:
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>W28610_text</title>
        <link rel="stylesheet" type="text/css" href="style.css" />

                «

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">WELL SUMMARY

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">OPERATOR:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">LEASE:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">API:
LOCATION:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">ELEVATION:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">SPUD DATE:
CEASE DRILLING:
TOTAL DEPTH:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">CONTRACTOR:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">CASING RECORD:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">MUD RECORD:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">DIRECTIONAL DRILLING PROGRAM:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">MUDLOGGING PROGRAM:

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">WHITING OIL AND GAS CORPORATION
Bartleson 13-18-3XH

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">33-061-03147
Field: Footage: Legal: Bottom Hole: Legal: County:
Kelly Bushing: Ground Level:

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">2,1250 mm 2253' r WL NWSW 18 T153N R92W
1,696' FNL & 828' FEL
Section 20 T153N R92W Mountrail County, North Dakota

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">July 10, 2014 August 16, 2014
20,032'MD 10,231.15' TVD 10,197.87' VS
Rig: Toolpusher: Drillers:

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Mike Heifern Glenn Lefucier, Rory Leduke, Chris Peterson, Gary Schwarm
9 5/8" set to 2,018' 1W) 7" set to 10,733' MD 5" liner set to TD
Ml SWACO Drew Richards 2 ,0 18 ' MD Invert

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Surface: Intermediate:
Production:
Mud Company: Mud engineer: Mud up depth:
Mud type:

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Directional company: Directional drillers: MWD Company: MWD Supervisors:
Mudlogging company: Mudlogger: Services:

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Baker Hughes Inteq
Nick Magnus, Ken Perry Baker Hughes Inteq
Will Rost, Prairie Newman
Neset Consulting Service, Inc Scott Strahm, Stephanie Connole Total Gas Detector

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Sanish Field
A 1AA! "A? RAF! "Ivy-r

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">2,074' 2,043'

    <p class="styleSans7.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Pioneer 67


text:
package org.hisp.dhis.webapi.controller.exception;

/**
 * @author Morten Olav Hansen <mortenoh@gmail.com>
 */
public class NotFoundException extends Exception
{
    public NotFoundException()
    {
        super( "Object not found." );
    }

    public NotFoundException( String uid )
    {
        super( "Object not found for uid: " + uid );
    }

    public NotFoundException( String type, String uid )
    {
        super( type + " not found for uid: " + uid );
    }
}


text:
class StoreController < ApplicationController
  include CurrentCart
  before_action :set_cart
  def index
    @products = Product.order(:title)

    #init view counter
    if session[:counter].nil?
      session[:counter] = 1
    else
      session[:counter] += 1
    end
  end
end


text:
<?php

namespace PC\PresentationBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class PageController extends Controller
{
    public function indexAction($page)
    {
        return $this->render('PCPresentationBundle::'.$page.'.html.twig', array("page" => $page));
    }
}