text:
#include <iostream>
#include <ctime>

#include "mtf/ThirdParty/MIL/object_tracker.h"

namespace mtf
{

	//---------------------------------------------------------------------------
	MILTrackerParams::MILTrackerParams()
	{
		// By default, use online boosting
		algorithm_ = CV_ONLINEBOOSTING;

		// Default number of classifiers/selectors for boosting algorithms
		num_classifiers_ = 100;

		// Default search region parameters for boosting algorithms
		overlap_ = 0.99f;
		search_factor_ = 2.0f;

		// Defaults for MIL tracker
		pos_radius_train_ = 4.0f;
		neg_num_train_ = 65;
		num_features_ = 250;
	}

	//---------------------------------------------------------------------------
	MILTrackerParams::MILTrackerParams(const int algorithm, const int num_classifiers, const float overlap,
		const float search_factor, const float pos_radius_train,
		const int neg_num_train, const int num_features)
	{
		// Make sure a valid algorithm flag is used before storing it
		if((algorithm != CV_ONLINEBOOSTING) && (algorithm != CV_SEMIONLINEBOOSTING) && (algorithm != CV_ONLINEMIL)
			&& (algorithm != CV_LINEMOD))
		{
			// Use CV_ERROR?
			std::cerr << "MILTrackerParams::MILTrackerParams(...) -- ERROR!  Invalid algorithm choice.\n";
			exit(-1);
		}
		// Store it
		algorithm_ = algorithm;

		// Store the number of weak classifiers (any error checking done here?)
		num_classifiers_ = num_classifiers;

		// Store information about the searching
		overlap_ = overlap;
		search_factor_ = search_factor;

		// MIL parameters
		pos_radius_train_ = pos_radius_train;
		neg_num_train_ = neg_num_train;
		num_features_ = num_features;
	}

	//
	//
	//

	//---------------------------------------------------------------------------
	MILTrackingAlgorithm::MILTrackingAlgorithm()
	{
	}

	//---------------------------------------------------------------------------
	MILTrackingAlgorithm::~MILTrackingAlgorithm()
	{
	}

	//
	//
	//

	//---------------------------------------------------------------------------
	MILOnlineBoostingAlgorithm::MILOnlineBoostingAlgorithm()
		:
		MILTrackingAlgorithm(),
		tracker_(NULL),
		cur_frame_rep_(NULL),
		tracker_lost_(false)
	{
	}

	//---------------------------------------------------------------------------
	MILOnlineBoostingAlgorithm::~MILOnlineBoostingAlgorithm()
	{
		if(tracker_ != NULL)
		{
			delete tracker_;
			tracker_ = NULL;
		}

		if(cur_frame_rep_ != NULL)
		{
			delete cur_frame_rep_;
			cur_frame_rep_ = NULL;
		}
	}

	//---------------------------------------------------------------------------
	bool
		MILOnlineBoostingAlgorithm::initialize(const cv::Mat & image, const MILTrackerParams& params,
		const CvRect& init_bounding_box)
	{
		// Import the image
		import_image(image);

		// If the boosting tracker has already been allocated, first de-allocate it
		if(tracker_ != NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::initialize(...) -- WARNING!  Boosting tracker already initialized.  Resetting now...\n"
				<< std::endl;
			delete tracker_;
			tracker_ = NULL;
		}

		// Do the same for the image frame representation
		if(cur_frame_rep_ != NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::initialize(...) -- WARNING!  Boosting tracker already initialized.  Resetting now...\n"
				<< std::endl;
			delete cur_frame_rep_;
			cur_frame_rep_ = NULL;
		}

		// (Re-)Initialize the boosting tracker
		cv::Size imageSize(image_.cols, image_.rows);
		cur_frame_rep_ = new boosting::ImageRepresentation(image_, imageSize);
		cv::Rect wholeImage(0, 0, imageSize.width, imageSize.height);
		cv::Rect tracking_rect = init_bounding_box;
		tracking_rect_size_ = cv::Size(tracking_rect.width, tracking_rect.height);
		tracker_ = new boosting::BoostingTracker(cur_frame_rep_, tracking_rect, wholeImage, params.num_classifiers_);

		// Initialize some useful tracking debugging information
		tracker_lost_ = false;

		// Return success
		return true;
	}

	//---------------------------------------------------------------------------
	bool
		MILOnlineBoostingAlgorithm::update(const cv::Mat & image, const MILTrackerParams& params, cv::Rect & track_box)
	{
		// Import the image
		import_image(image);

		// Make sure the tracker has already been successfully initialized
		if(tracker_ == NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::update(...) -- ERROR!  Trying to call update without properly initializing the tracker!\n"
				<< std::endl;
			return false;
		}
		if(cur_frame_rep_ == NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::update(...) -- ERROR!  Trying to call update without properly initializing the tracker!\n"
				<< std::endl;
			return false;
		}

		// Calculate the patches within the search region
		cv::Size imageSize(image_.cols, image_.rows);
		cv::Rect wholeImage(0, 0, imageSize.width, imageSize.height);
		boosting::Patches *trackingPatches;
		cv::Rect searchRegion = tracker_->getTrackingROI(params.search_factor_);
		trackingPatches = new boosting::PatchesRegularScan(searchRegion, wholeImage, tracking_rect_size_, params.overlap_);

		cur_frame_rep_->setNewImageAndROI(image_, searchRegion);

		if(!tracker_->track(cur_frame_rep_, trackingPatches))
		{
			tracker_lost_ = true;
		} else
		{
			tracker_lost_ = false;
		}

		delete trackingPatches;

		// Save the new tracking ROI
		track_box = tracker_->getTrackedPatch();
		std::cout << "\rTracking confidence = " << tracker_->getConfidence();

		// Return success or failure based on whether or not the tracker has been lost
		return !tracker_lost_;
	}

	//---------------------------------------------------------------------------
	void
		MILOnlineBoostingAlgorithm::import_image(const cv::Mat & image)
	{
		// We want the internal version of the image to be gray-scale, so let's
		// do that here.  We'll handle cases where the input is either RGB, RGBA,
		// or already gray-scale.  I assume it's already 8-bit.  If not then
		// an error is thrown.  I'm not going to deal with converting properly
		// from every data type since that shouldn't be happening.

		// Make sure the input image pointer is valid
		if(image.empty())
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Input image pointer is NULL!\n" << std::endl;
			exit(0); // <--- CV_ERROR?
		}

		// Now copy it in appropriately as a gray-scale, 8-bit image
		if(image.channels() == 4)
		{
			cv::cvtColor(image, image_, CV_RGBA2GRAY);
		} else if(image.channels() == 3)
		{
			cv::cvtColor(image, image_, CV_RGB2GRAY);
		} else if(image.channels() == 1)
		{
			image.copyTo(image_);
		} else
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Invalid number of channels for input image!\n"
				<< std::endl;
			exit(0);
		}
	}
	//
	//
	//

	//---------------------------------------------------------------------------
	MILSemiOnlineBoostingAlgorithm::MILSemiOnlineBoostingAlgorithm()
		:
		MILTrackingAlgorithm(),
		tracker_(0),
		cur_frame_rep_(0),
		tracker_lost_(false)
	{
	}

	//---------------------------------------------------------------------------
	MILSemiOnlineBoostingAlgorithm::~MILSemiOnlineBoostingAlgorithm()
	{
		if(tracker_ != NULL)
		{
			delete tracker_;
			tracker_ = NULL;
		}

		if(cur_frame_rep_ != NULL)
		{
			delete cur_frame_rep_;
			cur_frame_rep_ = NULL;
		}
	}

	//---------------------------------------------------------------------------
	bool
		MILSemiOnlineBoostingAlgorithm::initialize(const cv::Mat & image, const MILTrackerParams& params,
		const CvRect& init_bounding_box)
	{
		// Import the image
		import_image(image);

		// If the boosting tracker has already been allocated, first de-allocate it
		if(tracker_ != NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::initialize(...) -- WARNING!  Boosting tracker already initialized.  Resetting now...\n"
				<< std::endl;
			delete tracker_;
			tracker_ = NULL;
		}

		// Do the same for the image frame representation
		if(cur_frame_rep_ != NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::initialize(...) -- WARNING!  Boosting tracker already initialized.  Resetting now...\n"
				<< std::endl;
			delete cur_frame_rep_;
			cur_frame_rep_ = NULL;
		}

		// (Re-)Initialize the boosting tracker
		cv::Size imageSize(image_.cols, image_.rows);
		cur_frame_rep_ = new boosting::ImageRepresentation(image_, imageSize);
		cv::Rect wholeImage = cv::Rect(0, 0, imageSize.width, imageSize.height);
		cv::Rect tracking_rect = init_bounding_box;
		tracking_rect_size_ = cv::Size(tracking_rect.width, tracking_rect.height);
		tracker_ = new boosting::SemiBoostingTracker(cur_frame_rep_, tracking_rect, wholeImage, params.num_classifiers_);

		// Initialize some useful tracking debugging information
		tracker_lost_ = false;

		// Return success
		return true;
	}

	//---------------------------------------------------------------------------
	bool
		MILSemiOnlineBoostingAlgorithm::update(const cv::Mat & image, const MILTrackerParams& params, cv::Rect & track_box)
	{
		// Import the image
		import_image(image);

		// Make sure the tracker has already been successfully initialized
		if(tracker_ == NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::update(...) -- ERROR!  Trying to call update without properly initializing the tracker!\n"
				<< std::endl;
			return false;
		}
		if(cur_frame_rep_ == NULL)
		{
			std::cerr
				<< "OnlineBoostingAlgorithm::update(...) -- ERROR!  Trying to call update without properly initializing the tracker!\n"
				<< std::endl;
			return false;
		}

		// Calculate the patches within the search region
		cv::Size imageSize(image_.cols, image_.rows);
		cv::Rect wholeImage = cv::Rect(0, 0, imageSize.width, imageSize.height);
		boosting::Patches *trackingPatches;
		cv::Rect searchRegion = tracker_->getTrackingROI(params.search_factor_);
		trackingPatches = new boosting::PatchesRegularScan(searchRegion, wholeImage, tracking_rect_size_, params.overlap_);

		cur_frame_rep_->setNewImageAndROI(image_, searchRegion);

		if(!tracker_->track(cur_frame_rep_, trackingPatches))
		{
			tracker_lost_ = true;
		} else
		{
			tracker_lost_ = false;
		}

		delete trackingPatches;

		// Save the new tracking ROI
		track_box = tracker_->getTrackedPatch();
		std::cout << "\rTracking confidence = " << tracker_->getConfidence();

		// Return success or failure based on whether or not the tracker has been lost
		return !tracker_lost_;
	}

	//---------------------------------------------------------------------------
	void
		MILSemiOnlineBoostingAlgorithm::import_image(const cv::Mat & image)
	{
		// We want the internal version of the image to be gray-scale, so let's
		// do that here.  We'll handle cases where the input is either RGB, RGBA,
		// or already gray-scale.  I assume it's already 8-bit.  If not then
		// an error is thrown.  I'm not going to deal with converting properly
		// from every data type since that shouldn't be happening.

		// Make sure the input image pointer is valid
		if(image.empty())
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Input image pointer is NULL!\n" << std::endl;
			exit(0); // <--- CV_ERROR?
		}

		// Now copy it in appropriately as a gray-scale, 8-bit image
		if(image.channels() == 4)
		{
			cv::cvtColor(image, image_, CV_RGBA2GRAY);
		} else if(image.channels() == 3)
		{
			cv::cvtColor(image, image_, CV_RGB2GRAY);
		} else if(image.channels() == 1)
		{
			image.copyTo(image_);
		} else
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Invalid number of channels for input image!\n"
				<< std::endl;
			exit(0);
		}
	}

	//
	//
	//

	//---------------------------------------------------------------------------
	MILOnlineMILAlgorithm::MILOnlineMILAlgorithm()
		:
		MILTrackingAlgorithm(),
		is_initialized(false)
	{
		mtf::mil::RandomGenerator::initialize((int)time(0));
		clfparams_ = new mtf::mil::ClfMilBoostParams();
		ftrparams_ = &haarparams_;
		clfparams_->_ftrParams = ftrparams_;
	}

	//---------------------------------------------------------------------------
	MILOnlineMILAlgorithm::~MILOnlineMILAlgorithm()
	{
		delete clfparams_;
	}

	//---------------------------------------------------------------------------
	bool
		MILOnlineMILAlgorithm::initialize(const cv::Mat & image, const MILTrackerParams& params,
		const CvRect& init_bounding_box)
	{
		import_image(image);

		((mtf::mil::ClfMilBoostParams*) clfparams_)->_numSel = params.num_classifiers_;
		((mtf::mil::ClfMilBoostParams*) clfparams_)->_numFeat = params.num_features_;
		tracker_params_._posradtrain = params.pos_radius_train_;
		tracker_params_._negnumtrain = params.neg_num_train_;

		// Tracking parameters
		tracker_params_._init_negnumtrain = 65;
		tracker_params_._init_postrainrad = 3.0f;
		tracker_params_._initstate[0] = (float)init_bounding_box.x;
		tracker_params_._initstate[1] = (float)init_bounding_box.y;
		tracker_params_._initstate[2] = (float)init_bounding_box.width;
		tracker_params_._initstate[3] = (float)init_bounding_box.height;
		tracker_params_._srchwinsz = 25;
		tracker_params_._negsamplestrat = 1;
		tracker_params_._initWithFace = false;
		tracker_params_._debugv = false;
		tracker_params_._disp = false; // set this to true if you want to see video output (though it slows things down)

		clfparams_->_ftrParams->_width = (mtf::mil::uint) init_bounding_box.width;
		clfparams_->_ftrParams->_height = (mtf::mil::uint) init_bounding_box.height;

		tracker_.init(image_, tracker_params_, clfparams_);

		// Return success
		is_initialized = true;
		return true;
	}

	//---------------------------------------------------------------------------
	bool
		MILOnlineMILAlgorithm::update(const cv::Mat & image, const MILTrackerParams& params, cv::Rect & track_box)
	{
		if(!is_initialized)
		{
			std::cerr << "OnlineMILAlgorithm::update() -- Error!  Did not intialize algorithm!\n" << std::endl;
			return false;
		}

		import_image(image);

		// Update tracker
		tracker_.track_frame(image_);

		// Save output
		tracker_.getTrackBox(track_box);

		// Return success
		return true;
	}

	//---------------------------------------------------------------------------
	void
		MILOnlineMILAlgorithm::import_image(const cv::Mat & image)
	{
		// We want the internal version of the image to be gray-scale, so let's
		// do that here.  We'll handle cases where the input is either RGB, RGBA,
		// or already gray-scale.  I assume it's already 8-bit.  If not then
		// an error is thrown.  I'm not going to deal with converting properly
		// from every data type since that shouldn't be happening.

		// Make sure the input image pointer is valid
		if(image.empty())
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Input image pointer is NULL!\n" << std::endl;
			exit(0); // <--- CV_ERROR?
		}

		// Now copy it in appropriately as a gray-scale, 8-bit image
		if(image.channels() == 4)
		{
			cv::cvtColor(image, image_, CV_RGBA2GRAY);
		} else if(image.channels() == 3)
		{
			cv::cvtColor(image, image_, CV_RGB2GRAY);
		} else if(image.channels() == 1)
		{
			image.copyTo(image_);
		} else
		{
			std::cerr << "OnlineBoostingAlgorithm::import_image(...) -- ERROR!  Invalid number of channels for input image!\n"
				<< std::endl;
			exit(0);
		}
	}

	//
	//
	//

	//---------------------------------------------------------------------------
	LINEMODAlgorithm::LINEMODAlgorithm()
		:
		MILTrackingAlgorithm()
	{
	}

	//---------------------------------------------------------------------------
	LINEMODAlgorithm::~LINEMODAlgorithm()
	{
	}

	//---------------------------------------------------------------------------
	bool
		LINEMODAlgorithm::initialize(const cv::Mat & image, const MILTrackerParams& params,
		const CvRect& init_bounding_box)
	{
		// Return success
		return true;
	}

	//---------------------------------------------------------------------------
	bool
		LINEMODAlgorithm::update(const cv::Mat & image, const MILTrackerParams& params, cv::Rect & track_box)
	{
		// Return success
		return true;
	}

	//---------------------------------------------------------------------------
	void
		LINEMODAlgorithm::import_image(const cv::Mat & image)
	{
	}

	//
	//
	//

	//---------------------------------------------------------------------------
	MILTracker::MILTracker(const MILTrackerParams& params)
		:
		initialized_(false),
		tracker_(NULL)
	{
		// Store configurable parameters internally
		set_params(params);

		// Allocate the proper tracking algorithm (note: error-checking that a valid
		// tracking algorithm parameter is used is done in the MILTrackerParams
		// constructor, so at this point we are confident it's valid).
		switch(params.algorithm_)
		{
		case MILTrackerParams::CV_ONLINEBOOSTING:
			tracker_ = new MILOnlineBoostingAlgorithm();
			break;
		case MILTrackerParams::CV_SEMIONLINEBOOSTING:
			tracker_ = new MILSemiOnlineBoostingAlgorithm();
			break;
		case MILTrackerParams::CV_ONLINEMIL:
			tracker_ = new MILOnlineMILAlgorithm();
			break;
		case MILTrackerParams::CV_LINEMOD:
			tracker_ = new LINEMODAlgorithm();
			break;
		default:
			// By default, if an invalid choice somehow gets through lets use online boosting?
			// Or throw an error and don't continue?
			tracker_ = new MILOnlineBoostingAlgorithm();
			break;
		}
	}

	//---------------------------------------------------------------------------
	MILTracker::~MILTracker()
	{
		// Delete the tracking algorithm object, if it was allocated properly
		if(tracker_ != NULL)
		{
			delete tracker_;
		}
	}

	//---------------------------------------------------------------------------
	bool
		MILTracker::initialize(const cv::Mat & image, const CvRect& bounding_box)
	{
		// Initialize the tracker and if it works, set the flag that we're now initialized
		// to true so that update() can work properly.
		//printf("Using MIL tracker with:\n");
		//printf("algorithm: %d\n", tracker_params_.algorithm_);
		//printf("num_classifiers: %d\n", tracker_params_.num_classifiers_);
		//printf("overlap: %f\n", tracker_params_.overlap_);
		//printf("search_factor: %f\n", tracker_params_.search_factor_);
		//printf("pos_radius_train: %f\n", tracker_params_.pos_radius_train_);
		//printf("neg_num_train: %d\n", tracker_params_.neg_num_train_);
		//printf("num_features: %d\n", tracker_params_.num_features_);
		//printf("\n");
		bool success = tracker_->initialize(image, tracker_params_, bounding_box);
		if(success)
		{
			initialized_ = true;
		} else
		{
			initialized_ = false;
		}

		// Return success or failure
		return success;
	}

	//---------------------------------------------------------------------------
	bool
		MILTracker::update(const cv::Mat & image, cv::Rect & track_box)
	{
		// First make sure we have already initialized.  Otherwise we can't continue.
		if(!initialized_)
		{
			std::cerr << "ObjectTracker::update() -- ERROR! The ObjectTracker needs to be initialized before updating.\n";
			return false;
		}

		// Update the tracker and return whether or not it succeeded
		bool success = tracker_->update(image, tracker_params_, track_box);

		// Return success or failure
		return success;
	}

	//---------------------------------------------------------------------------
	void
		MILTracker::set_params(const MILTrackerParams& params)
	{
		tracker_params_ = params;
	}

}


text:
package dwarf

import "strconv"

const (
	_Tag_name_0 = "ArrayTypeClassTypeEntryPointEnumerationTypeFormalParameter"
	_Tag_name_1 = "ImportedDeclaration"
	_Tag_name_2 = "LabelLexDwarfBlock"
	_Tag_name_3 = "Member"
	_Tag_name_4 = "PointerTypeReferenceTypeCompileUnitStringTypeStructType"
	_Tag_name_5 = "SubroutineTypeTypedefUnionTypeUnspecifiedParametersVariantCommonDwarfBlockCommonInclusionInheritanceInlinedSubroutineModulePtrToMemberTypeSetTypeSubrangeTypeWithStmtAccessDeclarationBaseTypeCatchDwarfBlockConstTypeConstantEnumeratorFileTypeFriendNamelistNamelistItemPackedTypeSubprogramTemplateTypeParameterTemplateValueParameterThrownTypeTryDwarfBlockVariantPartVariableVolatileTypeDwarfProcedureRestrictTypeInterfaceTypeNamespaceImportedModuleUnspecifiedTypePartialUnitImportedUnitMutableTypeConditionSharedTypeTypeUnitRvalueReferenceTypeTemplateAlias"
)

var (
	_Tag_index_0 = [...]uint8{0, 9, 18, 28, 43, 58}
	_Tag_index_2 = [...]uint8{0, 5, 18}
	_Tag_index_4 = [...]uint8{0, 11, 24, 35, 45, 55}
	_Tag_index_5 = [...]uint16{0, 14, 21, 30, 51, 58, 74, 89, 100, 117, 123, 138, 145, 157, 165, 182, 190, 205, 214, 222, 232, 240, 246, 254, 266, 276, 286, 307, 329, 339, 352, 363, 371, 383, 397, 409, 422, 431, 445, 460, 471, 483, 494, 503, 513, 521, 540, 553}
)

func (i Tag) String() string {
	switch {
	case 1 <= i && i <= 5:
		i -= 1
		return _Tag_name_0[_Tag_index_0[i]:_Tag_index_0[i+1]]
	case i == 8:
		return _Tag_name_1
	case 10 <= i && i <= 11:
		i -= 10
		return _Tag_name_2[_Tag_index_2[i]:_Tag_index_2[i+1]]
	case i == 13:
		return _Tag_name_3
	case 15 <= i && i <= 19:
		i -= 15
		return _Tag_name_4[_Tag_index_4[i]:_Tag_index_4[i+1]]
	case 21 <= i && i <= 67:
		i -= 21
		return _Tag_name_5[_Tag_index_5[i]:_Tag_index_5[i+1]]
	default:
		return "Tag(" + strconv.FormatInt(int64(i), 10) + ")"
	}
}

redpajama_set_name: RedPajamaGithub


text:
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008-2016. All Rights Reserved.                        */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project.                                                               */
/*----------------------------------------------------------------------------*/

package edu.wpi.first.wpilibj.image;

import com.ni.vision.NIVision;

/**
 * A color image represented in HSL color space at 3 bytes per pixel.
 *$
 * @author dtjones
 */
public class HSLImage extends ColorImage {

  /**
   * Create a new 0x0 image.
   */
  public HSLImage() throws NIVisionException {
    super(NIVision.ImageType.IMAGE_HSL);
  }

  HSLImage(HSLImage sourceImage) {
    super(sourceImage);
  }

  /**
   * Create a new image by loading a file.
   *$
   * @param fileName The path of the file to load.
   */
  public HSLImage(String fileName) throws NIVisionException {
    super(NIVision.ImageType.IMAGE_HSL);
    NIVision.imaqReadFile(image, fileName);
  }
}


text:
package com.parallelsymmetry.cirrus;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;

import javax.swing.JComponent;
import javax.swing.Painter;
import javax.swing.UIManager;
import javax.swing.plaf.UIResource;

/**
 * TableScrollPaneCorner - A simple component that paints itself using the table
 * header background painter. It is used to fill the top right corner of
 * scrollpane.
 *
 * @author Created by Jasper Potts (Jan 28, 2008)
 */
class TableScrollPaneCorner extends JComponent implements UIResource {

	/**
	 * Paint the component using the Cirrus Table Header Background Painter
	 */
	@Override
	protected void paintComponent( Graphics g ) {
		Painter painter = (Painter)UIManager.get( "TableHeader:\"TableHeader.renderer\"[Enabled].backgroundPainter" );
		if( painter != null ) {
			if( g instanceof Graphics2D ) {
				painter.paint( (Graphics2D)g, this, getWidth() + 1, getHeight() );
			} else {
				// paint using image to not Graphics2D to support
				// Java 1.1 printing API
				BufferedImage img = new BufferedImage( getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB );
				Graphics2D g2 = (Graphics2D)img.getGraphics();
				painter.paint( g2, this, getWidth() + 1, getHeight() );
				g2.dispose();
				g.drawImage( img, 0, 0, null );
				img = null;
			}
		}
	}
}


text:
namespace content {
namespace {

#ifndef STATIC_ASSERT_ENUM
#define STATIC_ASSERT_ENUM(a, b)                            \
  static_assert(static_cast<int>(a) == static_cast<int>(b), \
                "mismatching enums: " #a)
#endif

STATIC_ASSERT_ENUM(network::mojom::ResolverType::kResolverTypeFail,
                   net::RuleBasedHostResolverProc::Rule::kResolverTypeFail);
STATIC_ASSERT_ENUM(network::mojom::ResolverType::kResolverTypeSystem,
                   net::RuleBasedHostResolverProc::Rule::kResolverTypeSystem);
STATIC_ASSERT_ENUM(
    network::mojom::ResolverType::kResolverTypeIPLiteral,
    net::RuleBasedHostResolverProc::Rule::kResolverTypeIPLiteral);

void CrashResolveHost(const std::string& host_to_crash,
                      const std::string& host) {
  if (host_to_crash == host)
    base::Process::TerminateCurrentProcessImmediately(1);
}

class SimpleCache : public network::mojom::SimpleCache {
 public:
  explicit SimpleCache(std::unique_ptr<disk_cache::Backend> backend)
      : backend_(std::move(backend)) {}
  ~SimpleCache() override = default;

 private:
  std::unique_ptr<disk_cache::Backend> backend_;
};

}  // namespace

class NetworkServiceTestHelper::NetworkServiceTestImpl
    : public network::mojom::NetworkServiceTest,
      public base::CurrentThread::DestructionObserver {
 public:
  NetworkServiceTestImpl()
      : test_host_resolver_(new TestHostResolver()),
        memory_pressure_listener_(
            FROM_HERE,
            base::DoNothing(),
            base::BindRepeating(&NetworkServiceTestHelper::
                                    NetworkServiceTestImpl::OnMemoryPressure,
                                base::Unretained(this))) {
    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kUseMockCertVerifierForTesting)) {
      mock_cert_verifier_ = std::make_unique<net::MockCertVerifier>();
      network::NetworkContext::SetCertVerifierForTesting(
          mock_cert_verifier_.get());

      // The default result may be set using a command line flag.
      std::string default_result =
          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
              switches::kMockCertVerifierDefaultResultForTesting);
      int default_result_int = 0;
      if (!default_result.empty() &&
          base::StringToInt(default_result, &default_result_int)) {
        mock_cert_verifier_->set_default_result(default_result_int);
      }
    }
  }

  NetworkServiceTestImpl(const NetworkServiceTestImpl&) = delete;
  NetworkServiceTestImpl& operator=(const NetworkServiceTestImpl&) = delete;

  ~NetworkServiceTestImpl() override {
    network::NetworkContext::SetCertVerifierForTesting(nullptr);
  }

  // network::mojom::NetworkServiceTest:
  void AddRules(std::vector<network::mojom::RulePtr> rules,
                AddRulesCallback callback) override {
    // test_host_resolver_ may be empty if
    // SetAllowNetworkAccessToHostResolutions was invoked.
    DCHECK(test_host_resolver_);
    auto* host_resolver = test_host_resolver_->host_resolver();
    for (const auto& rule : rules) {
      switch (rule->resolver_type) {
        case network::mojom::ResolverType::kResolverTypeFail:
          host_resolver->AddSimulatedFailure(rule->host_pattern);
          break;
        case network::mojom::ResolverType::kResolverTypeFailTimeout:
          host_resolver->AddSimulatedTimeoutFailure(rule->host_pattern);
          break;
        case network::mojom::ResolverType::kResolverTypeIPLiteral: {
          net::IPAddress ip_address;
          DCHECK(ip_address.AssignFromIPLiteral(rule->replacement));
          host_resolver->AddRuleWithFlags(rule->host_pattern, rule->replacement,
                                          rule->host_resolver_flags,
                                          rule->dns_aliases);
          break;
        }
        case network::mojom::ResolverType::kResolverTypeDirectLookup:
          host_resolver->AllowDirectLookup(rule->host_pattern);
          break;
        default:
          host_resolver->AddRuleWithFlags(rule->host_pattern, rule->replacement,
                                          rule->host_resolver_flags,
                                          rule->dns_aliases);
          break;
      }
    }
    std::move(callback).Run();
  }

  void SimulateNetworkChange(network::mojom::ConnectionType type,
                             SimulateNetworkChangeCallback callback) override {
    DCHECK(!net::NetworkChangeNotifier::CreateIfNeeded());
    net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
        net::NetworkChangeNotifier::ConnectionType(type));
    std::move(callback).Run();
  }

  void SimulateNetworkQualityChange(
      net::EffectiveConnectionType type,
      SimulateNetworkChangeCallback callback) override {
    network::NetworkService::GetNetworkServiceForTesting()
        ->network_quality_estimator()
        ->SimulateNetworkQualityChangeForTesting(type);
    std::move(callback).Run();
  }

  void SimulateCrash() override {
    LOG(ERROR) << "Intentionally terminating current process to simulate"
                  " NetworkService crash for testing.";
    // Use |TerminateCurrentProcessImmediately()| instead of |CHECK()| to avoid
    // 'Fatal error' dialog on Windows debug.
    base::Process::TerminateCurrentProcessImmediately(1);
  }

  void MockCertVerifierSetDefaultResult(
      int32_t default_result,
      MockCertVerifierSetDefaultResultCallback callback) override {
    mock_cert_verifier_->set_default_result(default_result);
    std::move(callback).Run();
  }

  void MockCertVerifierAddResultForCertAndHost(
      const scoped_refptr<net::X509Certificate>& cert,
      const std::string& host_pattern,
      const net::CertVerifyResult& verify_result,
      int32_t rv,
      MockCertVerifierAddResultForCertAndHostCallback callback) override {
    mock_cert_verifier_->AddResultForCertAndHost(cert, host_pattern,
                                                 verify_result, rv);
    std::move(callback).Run();
  }

  void SetRequireCT(RequireCT required,
                    SetRequireCTCallback callback) override {
    net::TransportSecurityState::SetRequireCTForTesting(
        required == NetworkServiceTest::RequireCT::REQUIRE);
    std::move(callback).Run();
  }

  void SetTransportSecurityStateSource(
      uint16_t reporting_port,
      SetTransportSecurityStateSourceCallback callback) override {
    if (reporting_port) {
      transport_security_state_source_ =
          std::make_unique<net::ScopedTransportSecurityStateSource>(
              reporting_port);
    } else {
      transport_security_state_source_.reset();
    }
    std::move(callback).Run();
  }

  void SetAllowNetworkAccessToHostResolutions(
      SetAllowNetworkAccessToHostResolutionsCallback callback) override {
    DCHECK(!have_test_doh_servers_)
        << "Cannot allow network access when test DoH servers have been set.";
    test_host_resolver_.reset();
    std::move(callback).Run();
  }

  void ReplaceSystemDnsConfig(
      ReplaceSystemDnsConfigCallback callback) override {
    network::NetworkService::GetNetworkServiceForTesting()
        ->ReplaceSystemDnsConfigForTesting();
    std::move(callback).Run();
  }

  void SetTestDohConfig(net::SecureDnsMode secure_dns_mode,
                        const net::DnsOverHttpsConfig& doh_config,
                        SetTestDohConfigCallback callback) override {
    DCHECK(test_host_resolver_)
        << "Network access for host resolutions must be disabled.";
    have_test_doh_servers_ = true;
    network::NetworkService::GetNetworkServiceForTesting()
        ->SetTestDohConfigForTesting(secure_dns_mode, doh_config);
    std::move(callback).Run();
  }

  void CrashOnResolveHost(const std::string& host) override {
    network::HostResolver::SetResolveHostCallbackForTesting(
        base::BindRepeating(CrashResolveHost, host));
  }

  void CrashOnGetCookieList() override {
    network::CookieManager::CrashOnGetCookieList();
  }

  void GetLatestMemoryPressureLevel(
      GetLatestMemoryPressureLevelCallback callback) override {
    std::move(callback).Run(latest_memory_pressure_level_);
  }

  void GetPeerToPeerConnectionsCountChange(
      GetPeerToPeerConnectionsCountChangeCallback callback) override {
    uint32_t count = network::NetworkService::GetNetworkServiceForTesting()
                         ->network_quality_estimator()
                         ->GetPeerToPeerConnectionsCountChange();

    std::move(callback).Run(count);
  }

  void SetSCTAuditingRetryDelay(
      absl::optional<base::TimeDelta> delay,
      SetSCTAuditingRetryDelayCallback callback) override {
    network::SCTAuditingReporter::SetRetryDelayForTesting(delay);
    std::move(callback).Run();
  }

  void GetEnvironmentVariableValue(
      const std::string& name,
      GetEnvironmentVariableValueCallback callback) override {
    std::string value;
    base::Environment::Create()->GetVar(name, &value);
    std::move(callback).Run(value);
  }

  void Log(const std::string& message, LogCallback callback) override {
    LOG(ERROR) << message;
    std::move(callback).Run();
  }

  void ActivateFieldTrial(const std::string& field_trial_name) override {
    base::FieldTrialList::FindFullName(field_trial_name);
  }

  void BindReceiver(
      mojo::PendingReceiver<network::mojom::NetworkServiceTest> receiver) {
    receivers_.Add(this, std::move(receiver));
    if (!registered_as_destruction_observer_) {
      base::CurrentIOThread::Get()->AddDestructionObserver(this);
      registered_as_destruction_observer_ = true;
    }
  }

  // base::CurrentThread::DestructionObserver:
  void WillDestroyCurrentMessageLoop() override {
    // Needs to be called on the IO thread.
    receivers_.Clear();
  }

  void OpenFile(const base::FilePath& path,
                base::OnceCallback<void(bool)> callback) override {
    base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
    std::move(callback).Run(file.IsValid());
  }

  void CreateSimpleCache(
      mojo::PendingRemote<network::mojom::HttpCacheBackendFileOperationsFactory>
          factory,
      const base::FilePath& path,
      CreateSimpleCacheCallback callback) override {
    auto backend_holder = base::MakeRefCounted<
        base::RefCountedData<std::unique_ptr<disk_cache::Backend>>>();
    int rv = disk_cache::CreateCacheBackend(
        net::DISK_CACHE, net::CACHE_BACKEND_SIMPLE,
        base::MakeRefCounted<network::MojoBackendFileOperationsFactory>(
            std::move(factory)),
        path, 64 * 1024 * 1024, disk_cache::ResetHandling::kResetOnError,
        net::NetLog::Get(), &backend_holder->data,
        base::BindOnce(&NetworkServiceTestImpl::OnCacheCreated,
                       weak_factory_.GetWeakPtr(), backend_holder,
                       std::move(callback)));
    DCHECK_EQ(rv, net::ERR_IO_PENDING);
  }

 private:
  void OnMemoryPressure(
      base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
    latest_memory_pressure_level_ = memory_pressure_level;
  }

  void OnCacheCreated(
      scoped_refptr<base::RefCountedData<std::unique_ptr<disk_cache::Backend>>>
          backend_holder,
      CreateSimpleCacheCallback callback,
      int rv) {
    DCHECK(backend_holder);
    std::unique_ptr<disk_cache::Backend> backend =
        std::move(backend_holder->data);
    if (rv != net::OK) {
      DCHECK(!backend);
      std::move(callback).Run(mojo::NullRemote());
      return;
    }
    DCHECK(backend);
    mojo::PendingRemote<network::mojom::SimpleCache> remote;
    mojo::MakeSelfOwnedReceiver(
        std::make_unique<SimpleCache>(std::move(backend)),
        remote.InitWithNewPipeAndPassReceiver());
    std::move(callback).Run(std::move(remote));
  }

  bool registered_as_destruction_observer_ = false;
  bool have_test_doh_servers_ = false;
  mojo::ReceiverSet<network::mojom::NetworkServiceTest> receivers_;
  std::unique_ptr<TestHostResolver> test_host_resolver_;
  std::unique_ptr<net::MockCertVerifier> mock_cert_verifier_;
  std::unique_ptr<net::ScopedTransportSecurityStateSource>
      transport_security_state_source_;
  base::MemoryPressureListener memory_pressure_listener_;
  base::MemoryPressureListener::MemoryPressureLevel
      latest_memory_pressure_level_ =
          base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
  std::unique_ptr<disk_cache::Backend> disk_cache_backend_;

  base::WeakPtrFactory<NetworkServiceTestImpl> weak_factory_{this};
};

NetworkServiceTestHelper::NetworkServiceTestHelper()
    : network_service_test_impl_(new NetworkServiceTestImpl) {}

NetworkServiceTestHelper::~NetworkServiceTestHelper() = default;

void NetworkServiceTestHelper::RegisterNetworkBinders(
    service_manager::BinderRegistry* registry) {
  registry->AddInterface(base::BindRepeating(
      &NetworkServiceTestHelper::BindNetworkServiceTestReceiver,
      base::Unretained(this)));
}

void NetworkServiceTestHelper::BindNetworkServiceTestReceiver(
    mojo::PendingReceiver<network::mojom::NetworkServiceTest> receiver) {
  network_service_test_impl_->BindReceiver(std::move(receiver));
}

}  // namespace content


text:
package org.elasticmq.actor.queue

import scala.annotation.tailrec
import org.elasticmq._
import org.elasticmq.msg._
import org.joda.time.DateTime
import org.elasticmq.util.Logging
import org.elasticmq.util.NowProvider
import org.elasticmq.OnDateTimeReceived
import scala.Some
import org.elasticmq.NewMessageData
import org.elasticmq.msg.DeleteMessage
import org.elasticmq.MessageId
import org.elasticmq.msg.SendMessage
import org.elasticmq.MessageData
import org.elasticmq.MillisNextDelivery
import org.elasticmq.msg.ReceiveMessages
import org.elasticmq.msg.UpdateVisibilityTimeout
import org.elasticmq.msg.LookupMessage
import org.elasticmq.actor.reply._

trait QueueActorMessageOps extends Logging {
  this: QueueActorStorage =>

  def nowProvider: NowProvider

  def receiveAndReplyMessageMsg[T](msg: QueueMessageMsg[T]): ReplyAction[T] = msg match {
    case SendMessage(message) => sendMessage(message)
    case UpdateVisibilityTimeout(messageId, visibilityTimeout) => updateVisibilityTimeout(messageId, visibilityTimeout)
    case ReceiveMessages(visibilityTimeout, count, waitForMessages) => receiveMessages(visibilityTimeout, count)
    case DeleteMessage(deliveryReceipt) => deleteMessage(deliveryReceipt)
    case LookupMessage(messageId) => messagesById.get(messageId.id).map(_.toMessageData)
  }

  private def sendMessage(message: NewMessageData) = {
    val internalMessage = InternalMessage.from(message)
    messageQueue += internalMessage
    messagesById(internalMessage.id) = internalMessage

    logger.debug(s"${queueData.name}: Sent message with id ${internalMessage.id}")

    internalMessage.toMessageData
  }

  private def updateVisibilityTimeout(messageId: MessageId, visibilityTimeout: VisibilityTimeout) = {
    updateNextDelivery(messageId, computeNextDelivery(visibilityTimeout))
  }

  private def updateNextDelivery(messageId: MessageId, newNextDelivery: MillisNextDelivery) = {
    messagesById.get(messageId.id) match {
      case Some(internalMessage) => {
        // Updating
        val oldNextDelivery = internalMessage.nextDelivery
        internalMessage.nextDelivery = newNextDelivery.millis

        if (newNextDelivery.millis < oldNextDelivery) {
          // We have to re-insert the msg, as another msg with a bigger next delivery may be now before it,
          // so the msg wouldn't be correctly received.
          // (!) This may be slow (!)
          messageQueue = messageQueue.filterNot(_.id == internalMessage.id)
          messageQueue += internalMessage
        }
        // Else:
        // Just increasing the next delivery. Common case. It is enough to increase the value in the object. No need to
        // re-insert the msg into the queue, as it will be reinserted if needed during receiving.

        logger.debug(s"${queueData.name}: Updated next delivery of $messageId to $newNextDelivery")

        Right(())
      }

      case None => Left(new MessageDoesNotExist(queueData.name, messageId))
    }
  }

  protected def receiveMessages(visibilityTimeout: VisibilityTimeout,
                                count: Int): List[MessageData] = {
    val deliveryTime = nowProvider.nowMillis

    @tailrec
    def doReceiveMessages(left: Int, acc: List[MessageData]): List[MessageData] = {
      if (left == 0) {
        acc
      } else {
        receiveMessage(deliveryTime, computeNextDelivery(visibilityTimeout)) match {
          case None => acc
          case Some(msg) => doReceiveMessages(left - 1, msg :: acc)
        }
      }
    }

    doReceiveMessages(count, Nil)
  }

  @tailrec
  private def receiveMessage(deliveryTime: Long, newNextDelivery: MillisNextDelivery): Option[MessageData] = {
    if (messageQueue.size == 0) {
      None
    } else {
      val internalMessage = messageQueue.dequeue()
      val id = MessageId(internalMessage.id)
      if (internalMessage.nextDelivery > deliveryTime) {
        // Putting the msg back. That's the youngest msg, so there is no msg that can be received.
        messageQueue += internalMessage
        None
      } else if (messagesById.contains(id.id)) {
        // Putting the msg again into the queue, with a new next delivery
        internalMessage.deliveryReceipt = Some(DeliveryReceipt.generate(id).receipt)
        internalMessage.nextDelivery = newNextDelivery.millis

        internalMessage.receiveCount += 1
        internalMessage.firstReceive = OnDateTimeReceived(new DateTime(deliveryTime))

        messageQueue += internalMessage

        logger.debug(s"${queueData.name}: Receiving message $id")

        Some(internalMessage.toMessageData)
      } else {
        // Deleted msg - trying again
        receiveMessage(deliveryTime, newNextDelivery)
      }
    }
  }

  private def computeNextDelivery(visibilityTimeout: VisibilityTimeout) = {
    val nextDeliveryDelta = visibilityTimeout match {
      case DefaultVisibilityTimeout => queueData.defaultVisibilityTimeout.millis
      case MillisVisibilityTimeout(millis) => millis
    }

    MillisNextDelivery(nowProvider.nowMillis + nextDeliveryDelta)
  }

  private def deleteMessage(deliveryReceipt: DeliveryReceipt) {
    val msgId = deliveryReceipt.extractId.toString

    messagesById.get(msgId).foreach { msgData =>
      if (msgData.deliveryReceipt == Some(deliveryReceipt.receipt)) {
        // Just removing the msg from the map. The msg will be removed from the queue when trying to receive it.
        messagesById.remove(msgId)
      }
    }
  }
}


text:
package com.datastax.oss.driver.mapper;

import static com.datastax.oss.driver.assertions.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
import static org.assertj.core.data.Offset.offset;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.mapper.annotations.ClusteringColumn;
import com.datastax.oss.driver.api.mapper.annotations.Computed;
import com.datastax.oss.driver.api.mapper.annotations.CqlName;
import com.datastax.oss.driver.api.mapper.annotations.Dao;
import com.datastax.oss.driver.api.mapper.annotations.DaoFactory;
import com.datastax.oss.driver.api.mapper.annotations.DaoKeyspace;
import com.datastax.oss.driver.api.mapper.annotations.Delete;
import com.datastax.oss.driver.api.mapper.annotations.Entity;
import com.datastax.oss.driver.api.mapper.annotations.GetEntity;
import com.datastax.oss.driver.api.mapper.annotations.Insert;
import com.datastax.oss.driver.api.mapper.annotations.Mapper;
import com.datastax.oss.driver.api.mapper.annotations.PartitionKey;
import com.datastax.oss.driver.api.mapper.annotations.Query;
import com.datastax.oss.driver.api.mapper.annotations.Select;
import com.datastax.oss.driver.api.mapper.annotations.SetEntity;
import com.datastax.oss.driver.api.mapper.annotations.Update;
import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
import com.datastax.oss.driver.api.testinfra.session.SessionRule;
import com.datastax.oss.driver.categories.ParallelizableTests;
import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.rules.RuleChain;
import org.junit.rules.TestRule;

@Category(ParallelizableTests.class)
public class ComputedIT {

  private static final CcmRule CCM_RULE = CcmRule.getInstance();

  private static final SessionRule<CqlSession> SESSION_RULE = SessionRule.builder(CCM_RULE).build();

  @ClassRule
  public static final TestRule CHAIN = RuleChain.outerRule(CCM_RULE).around(SESSION_RULE);

  private static TestMapper mapper;

  private static AtomicInteger keyProvider = new AtomicInteger();

  @BeforeClass
  public static void setup() {
    CqlSession session = SESSION_RULE.session();

    for (String query :
        ImmutableList.of(
            "CREATE TABLE computed_entity(id int, c_id int, v int, primary key (id, c_id))")) {
      session.execute(
          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
    }

    mapper = new ComputedIT_TestMapperBuilder(session).build();
  }

  @Test
  public void should_not_include_computed_values_in_insert() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.save(entity);

    ComputedEntity retrievedValue = computedDao.findById(key, 1);
    assertThat(retrievedValue.getId()).isEqualTo(key);
    assertThat(retrievedValue.getcId()).isEqualTo(1);
    assertThat(retrievedValue.getV()).isEqualTo(2);
  }

  @Test
  public void should_return_computed_values_in_select() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    long time = System.currentTimeMillis() - 1000;
    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.saveWithTime(entity, 3600, time);

    ComputedEntity retrievedValue = computedDao.findById(key, 1);
    assertThat(retrievedValue.getId()).isEqualTo(key);
    assertThat(retrievedValue.getcId()).isEqualTo(1);
    assertThat(retrievedValue.getV()).isEqualTo(2);
    assertThat(retrievedValue.getTtl()).isCloseTo(3600, offset(10));
    assertThat(retrievedValue.getWritetime()).isEqualTo(time);
  }

  @Test
  public void should_not_include_computed_values_in_delete() {
    // should not be the case since delete operates on primary key..
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.save(entity);

    // retrieve values so computed values are present.
    ComputedEntity retrievedValue = computedDao.findById(key, 1);

    computedDao.delete(retrievedValue);

    assertThat(computedDao.findById(key, 1)).isNull();
  }

  @Test
  public void should_not_include_computed_values_in_SetEntity() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    CqlSession session = SESSION_RULE.session();
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO computed_entity (id, c_id, v) VALUES (?, ?, ?)");
    BoundStatementBuilder builder = preparedStatement.boundStatementBuilder();
    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    BoundStatement statement = computedDao.set(builder, entity).build();
    session.execute(statement);

    // retrieve values to ensure was successful.
    ComputedEntity retrievedValue = computedDao.findById(key, 1);

    assertThat(retrievedValue.getId()).isEqualTo(key);
    assertThat(retrievedValue.getcId()).isEqualTo(1);
    assertThat(retrievedValue.getV()).isEqualTo(2);
  }

  @Test
  public void should_return_computed_values_in_GetEntity() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    long time = System.currentTimeMillis() - 1000;
    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.saveWithTime(entity, 3600, time);

    CqlSession session = SESSION_RULE.session();

    /*
     * Query with the computed values included.
     *
     * Since the mapper expects the result name to match the property name, we used aliasing
     * here.
     *
     * In the case of ttl(v), since we annotated ttl as @CqlName("myttl") we expect myttl to
     * be the alias.
     */
    ResultSet result =
        session.execute(
            SimpleStatement.newInstance(
                "select id, c_id, v, writetime(v) as writetime, ttl(v) as myttl from "
                    + "computed_entity where "
                    + "id=? and "
                    + "c_id=? limit 1",
                key,
                1));
    assertThat(result.getAvailableWithoutFetching()).isEqualTo(1);

    ComputedEntity retrievedValue = computedDao.get(result.one());
    assertThat(retrievedValue.getId()).isEqualTo(key);
    assertThat(retrievedValue.getcId()).isEqualTo(1);
    assertThat(retrievedValue.getV()).isEqualTo(2);

    // these should be set
    assertThat(retrievedValue.getTtl()).isCloseTo(3600, offset(10));
    assertThat(retrievedValue.getWritetime()).isEqualTo(time);
  }

  @Test
  public void should_fail_if_alias_does_not_match_cqlName() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    long time = System.currentTimeMillis() - 1000;
    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.saveWithTime(entity, 3600, time);

    CqlSession session = SESSION_RULE.session();

    /*
     * Query with the computed values included.
     *
     * Since the mapper expects the result name to match the property name, we used aliasing
     * here and used the wrong name for the alias 'notwritetime' which does not map to the cqlName.
     */
    ResultSet result =
        session.execute(
            SimpleStatement.newInstance(
                "select id, c_id, v, writetime(v) as notwritetime, ttl(v) as myttl from "
                    + "computed_entity where "
                    + "id=? and "
                    + "c_id=? limit 1",
                key,
                1));

    // should raise an exception as 'writetime' is not found in result set.
    Throwable t = catchThrowable(() -> computedDao.get(result.one()));

    assertThat(t)
        .isInstanceOf(IllegalArgumentException.class)
        .hasMessage("writetime is not a column in this row");
  }

  @Test
  public void should_return_computed_values_in_query() {
    ComputedDao computedDao = mapper.computedDao(SESSION_RULE.keyspace());
    int key = keyProvider.incrementAndGet();

    long time = System.currentTimeMillis() - 1000;
    ComputedEntity entity = new ComputedEntity(key, 1, 2);
    computedDao.saveWithTime(entity, 3600, time);

    ComputedEntity retrievedValue = computedDao.findByIdQuery(key, 1);
    assertThat(retrievedValue.getId()).isEqualTo(key);
    assertThat(retrievedValue.getcId()).isEqualTo(1);
    assertThat(retrievedValue.getV()).isEqualTo(2);

    // these should be set
    assertThat(retrievedValue.getTtl()).isCloseTo(3600, offset(10));
    assertThat(retrievedValue.getWritetime()).isEqualTo(time);
  }

  @Entity
  public static class ComputedEntity {

    @PartitionKey private int id;

    @ClusteringColumn private int cId;

    private int v;

    @Computed("writetime(v)")
    private long writetime;

    // use CqlName to ensure it is used for the alias.
    @CqlName("myttl")
    @Computed("ttl(v)")
    private int ttl;

    public ComputedEntity() {}

    public ComputedEntity(int id, int cId, int v) {
      this.id = id;
      this.cId = cId;
      this.v = v;
    }

    public int getId() {
      return id;
    }

    public void setId(int id) {
      this.id = id;
    }

    public int getcId() {
      return cId;
    }

    public void setcId(int cId) {
      this.cId = cId;
    }

    public int getV() {
      return v;
    }

    public void setV(int v) {
      this.v = v;
    }

    public long getWritetime() {
      return writetime;
    }

    public void setWritetime(long writetime) {
      this.writetime = writetime;
    }

    public int getTtl() {
      return ttl;
    }

    public void setTtl(int ttl) {
      this.ttl = ttl;
    }
  }

  @Dao
  public interface ComputedDao {
    @Select
    ComputedEntity findById(int id, int cId);

    @Insert(nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    void save(ComputedEntity entity);

    @Insert(
        ttl = ":ttl",
        timestamp = ":writeTime",
        nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    void saveWithTime(ComputedEntity entity, int ttl, long writeTime);

    @Delete
    void delete(ComputedEntity entity);

    @SetEntity(nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    BoundStatementBuilder set(BoundStatementBuilder builder, ComputedEntity computedEntity);

    @GetEntity
    ComputedEntity get(Row row);

    @Query(
        value =
            "select id, c_id, v, ttl(v) as myttl, writetime(v) as writetime from "
                + "${qualifiedTableId} WHERE id = :id and "
                + "c_id = :cId",
        nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    ComputedEntity findByIdQuery(int id, int cId);

    @Update(nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    void update(ComputedEntity entity);
  }

  @Mapper
  public interface TestMapper {
    @DaoFactory
    ComputedDao computedDao(@DaoKeyspace CqlIdentifier keyspace);
  }
}


text:
standalone systemd service along with dbase backup by logrotate and pause/resume scripts
# 1.1.4
* Latest release with all the report scripts and tess utility bundled with the tessdb service
#| 1.0.5
* Added `tess instrument history` command to tess utility

#| 1.0.4
* Added `tess location create` command to tess utility
* Added `tess location update` command to tess utility

## 1.0.3

* changed filter column default vaue from `DG` to `UVIR`
* Updated README.md.

## 1.0.2

* fixed --log option to `tess instrument list` command line utility

## 1.0.1

* Doc fixes.
* Added context (row info) to logfile in SQL Exception when writting samples.
* Added various options to `tess` command line utility.

## 1.0.0

* Renaming columns for zero point and dates in `tess_t` table
* Added a `filter` column in `tess_t` table to manage filters
* Changed `tess` command line utility to manage TESS filters

## 0.x.y

Eariler prototype versions.


text:
Simple static file (+ markdown) server.

## goal

Another static file server? Why buttle? Well... if you came here looking for a
blazing fast server of static files, something with caching and compression
options then you're in luck, [that does exist][1]! It just isn't buttle.

Buttle is tailored for use in *development*. It has baked in live reloading for
html and markdown files. It'll on-the-fly convert your LESS filess to CSS... and
cache nothing because it assumes you're actively hacking away. With buttle you
can test drive that angular app you just cloned or maybe have your test runner
page refresh whenever a source file is changed.

## get it

```
npm install -g buttle
```

## usage

```
buttle
```

Now you're serving files from your current working directory.

## super advanced usage

Use your favorite port:

```
buttle --port [your favorite port]
```

Disable automatic directory listing:

```
buttle --nodir
```

Live reload your html and markdown pages whenever watched files change (HTML pages need at least a `<body>` or `<html>` tag):

```
buttle --watch '**/*.md'
```

Open files on server startup:

```
buttle --open index.html
```

Set automatic index file names:

```
buttle --index foo.html,bar.html
```

Set the number of ports to attempt if your original or default port is busy:

```
buttle --max-attempts [number of attempts]
```

## other fancy features

### on the fly less conversion

Requests for `styles/main.css` will also find `styles/main.less` if the vanilla
CSS file does not exist.

### basic `php` support

Buttle will happily serve up your `.php` files. Make sure `php` is in your path
or provide a path to the php binary with the `--php-bin` flag on the command
line or the `phpBin` property in your `.buttlerc` file.

### read .buttlerc for options

It's can be a pain to specify the same config options over and over. Place a
JSON file named `.buttlerc` in the directory your run `buttle` from:

```javascript
{
  "port": 9000,
  "open": "README.md",
  "watch": "*.md",
  "phpBin": "/path/to/php/executable"
}
```

## changelog

- v0.2.0 Try strarting the server on a different port if we fail the first (N)
  time(s)
- v0.0.10 Allow for arbitrary php binaries
- v0.0.7 Add "index" detection
- v0.0.6 Read .buttlerc for options if it exists
- v0.0.5 Add support for opening files on server startup
- v0.0.4 Add ability to list directory contents

## license

MIT

[1]: https://github.com/isaacs/st "Production ready static file server"


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
 * The production Assertion :: ^ evaluates by returning an internal AssertionTester closure that takes a State argument x and performs the ...
 *
 * @path ch15/15.10/15.10.2/15.10.2.6/S15.10.2.6_A2_T1.js
 * @description Execute /^m/.test("pairs\nmakes\tdouble") and check results
 */

__executed = /^m/.test("pairs\nmakes\tdouble");

//CHECK#1
if (__executed) {
	$ERROR('#1: /^m/.test("pairs\\nmakes\\tdouble") === false');
}


text:
NS_ASSUME_NONNULL_BEGIN

@interface Photo (CoreDataProperties)

@property (nullable, nonatomic, retain) NSNumber *albumId;
@property (nullable, nonatomic, retain) NSNumber *photoId;
@property (nullable, nonatomic, retain) NSString *thumbnailUrl;
@property (nullable, nonatomic, retain) NSString *title;
@property (nullable, nonatomic, retain) NSString *url;

@end

NS_ASSUME_NONNULL_END


text:
package org.apache.camel.processor.aggregate;

import java.util.List;

import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.support.DefaultExchange;

/**
 * Aggregate all {@link Message} into a single combined Exchange holding all the
 * aggregated messages in a {@link List} of {@link Message} as the message body.
 *
 * This aggregation strategy can used in combination with {@link org.apache.camel.processor.Splitter} to batch messages
 */
public class GroupedMessageAggregationStrategy extends AbstractListAggregationStrategy<Message> {

    @Override
    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
        if (oldExchange == null) {
            // for the first time we must create a new empty exchange as the
            // holder, as the outgoing exchange
            // must not be one of the grouped exchanges, as that causes a
            // endless circular reference
            oldExchange = new DefaultExchange(newExchange);
        }
        return super.aggregate(oldExchange, newExchange);
    }

    @Override
    public Message getValue(Exchange exchange) {
        return exchange.getIn();
    }
}


text:
// Dependencies.
const React = require('react');
const ReactDOM = require('react-dom');
import builder from 'focus-core/component/builder';
import types from 'focus-core/component/types';
const assign = require('object-assign');

const mdlBehaviour = require('../../../../common/mixin/mdl-behaviour');
const i18nBehaviour = require('../../../../common/i18n/mixin');

/**
* Identity function.
* @param  {object} d - The data.
*/
const identity = d => d;

/**
* Input text mixin.
* @type {Object}
*/
const inputTextComponent = {
    mixins: [mdlBehaviour, i18nBehaviour],

    /** @inheritdoc */
    getDefaultProps() {
        return {
            type: 'text',
            /**
            * Default formatter.
            * @param  {object} d - Data to format.
            * @return {object}   - The formatted data.
            */
            formatter: identity,
            /**
            * Default unformatter.
            * @param  {object} d - Data to unformat.
            * @return {object}   - The unformatted data.
            */
            unformatter: identity
        };
    },
    /** @inheritdoc */
    propTypes: {
        onChange: types('func'),
        onKeyPress: types('func'),
        error: types('string'),
        type: types('string'),
        value: types(['string', 'number']),
        name: types('string'),
        placeholder: types('string')
    },
    /** @inheritdoc */
    getInitialState() {
        const {formatter, value} = this.props;
        return {
            value: formatter(value)
        };
    },
    componentWillMount() {
        console.warn('FocusComponents 0.7.0: this component is deprecated, please use FocusComponents.components.input.Text');
    },
    /**
    * Update the component.
    * @param {object} newProps - The new props to update.
    */
    componentWillReceiveProps(newProps) {
        this.setState({value: this.props.formatter(newProps.value)});
    },
    /**
    * Get the value from the input in the DOM.
    * @return {object} - The value of the formatter.
    */
    getValue() {
        return this.props.unformatter(ReactDOM.findDOMNode(this.refs.inputText).value);
    },
    /**
    * Handle the change value of the input.
    * @param {object} event - The sanitize event of input.
    */
    _handleInputChange(event) {
        //On change handler.
        const {onChange} = this.props;
        if(onChange) {
            return onChange(event);
        } else {
            //Set the state then call the change handler.
            this.setState({value: event.target.value});
        }
    },
    /**
     * Input key press handler.
     * @param  {Object} event   event raised by the key press
     */
    _handleInputKeyPress(event) {
        const {onKeyPress} = this.props;
        if(onKeyPress) {
            onKeyPress(event);
        }
    },
    /**
    * Render an input.
    * @return {DOM} - The dom of an input.
    */
    render() {
        const {value} = this.state;
        const {error, name, placeholder, style} = this.props;
        const inputProps = assign({}, this.props, {value}, {id: name, onChange: this._handleInputChange, onKeyPress: this._handleInputKeyPress});
        const pattern = error ? 'hasError' : null; //add pattern to overide mdl error style when displaying an focus error.
        const cssClass = `mdl-textfield mdl-js-textfield ${error ? 'is-invalid' : ''}`;
        return (

                <input className='mdl-textfield__input' ref='inputText' {...inputProps} pattern={pattern} />
                {value ? '' : this.i18n(placeholder)}
                {error &&
                    {error}
                }

        );
    }
};

module.exports = builder(inputTextComponent);


text: apple watch test rep


text:
package domala.internal.expr

import java.util._

import org.seasar.doma.expr.ExpressionFunctions
import org.seasar.doma.internal.expr.{EvaluationResult, ExpressionException, NullExpressionFunctions, Value}
import org.seasar.doma.message.Message
import org.seasar.doma.internal.expr.node._
import org.seasar.doma.jdbc.ClassHelper
import org.seasar.doma.internal.util.{ClassUtil, GenericsUtil, MethodUtil}
import java.lang.reflect.{GenericDeclaration, ParameterizedType, TypeVariable}

// createEvaluationResultにてOptionのunwrapを行うために拡張
class ExpressionEvaluator(variableValues: java.util.Map[String, Value] =
                            Collections.emptyMap[String, Value],
                          expressionFunctions: ExpressionFunctions =
                            new NullExpressionFunctions(),
                          classHelper: ClassHelper = new ClassHelper() {})
    extends org.seasar.doma.internal.expr.ExpressionEvaluator(
      variableValues,
      expressionFunctions,
      classHelper) {

  def this(expressionFunctions: ExpressionFunctions, classHelper: ClassHelper) = {
    this(Collections.emptyMap[String, Value], expressionFunctions, classHelper)
  }

  override def visitFieldOperatorNode(node: FieldOperatorNode,
                                      p: Void): EvaluationResult = {
    val targetResult = node.getTargetObjectNode.accept(this, p)
    val target = targetResult.getValue
    val location = node.getLocation
    val field = findField(node.getFieldName, target.getClass)
    if (field == null) {
      val method = findMethod(node.getFieldName,
                              expressionFunctions,
                              target.getClass,
                              new Array[Class[_]](0))
      if (method == null) {
        throw new ExpressionException(Message.DOMA3018,
                                      location.getExpression,
                                      Integer.valueOf(location.getPosition),
                                      target.getClass.getName,
                                      node.getFieldName)
      }
      invokeMethod(node.getLocation,
                   method,
                   target,
                   target.getClass,
                   new Array[Class[_]](0),
                   new Array[Object](0))
    } else {
      getFieldValue(location, field, target)
    }
  }

  override protected def createEvaluationResult(target: Object, value: Object, valueClass: Class[_], genericType: java.lang.reflect.Type): EvaluationResult = {
    value match {
      case optional: Optional[_] =>
        genericType match {
          case parameterizedType: ParameterizedType =>
            val typeArguments = parameterizedType.getActualTypeArguments
            if (typeArguments.nonEmpty && typeArguments(0).isInstanceOf[Class[_]]) {
              val elementValue = if(optional.isPresent) optional.get() else null
              return new EvaluationResult(elementValue, typeArguments(0).asInstanceOf[Class[_]])
            }
          case _ => ()
        }
      case optional: OptionalInt =>
        val nullable = if (optional.isPresent) optional.getAsInt else null
        return new EvaluationResult(nullable, classOf[Integer])
      case optional: OptionalLong =>
        val nullable = if (optional.isPresent) java.lang.Long.valueOf(optional.getAsLong) else null
        return new EvaluationResult(nullable, classOf[Long])
      case optional: OptionalDouble =>
        val nullable = if (optional.isPresent) java.lang.Double.valueOf(optional.getAsDouble) else null
        return new EvaluationResult(nullable, classOf[Double])
      case option: Option[_] =>
        genericType match {
          case parameterizedType: ParameterizedType =>
            val typeArguments = parameterizedType.getActualTypeArguments
            if (typeArguments.nonEmpty) {
              typeArguments(0) match {
                case valueClass: Class[_] =>
                  val elementValue: Any = option.orNull
                  if(elementValue != null && !elementValue.getClass.isAssignableFrom(valueClass))
                    return new EvaluationResult(elementValue, elementValue.getClass)
                  else
                    return new EvaluationResult(elementValue, valueClass)
                case parameterizedType: ParameterizedType if parameterizedType.getRawType.isInstanceOf[Class[_]] =>
                  val  elementValue: Any = option.orNull
                  return new EvaluationResult(elementValue, parameterizedType.getRawType.asInstanceOf[Class[_]])
                case _ => ()
              }
            }
          case _ => ()
        }
      case _ =>
        if (target != null && genericType.isInstanceOf[TypeVariable[_ <: GenericDeclaration]]) {
          val typeArgument = GenericsUtil.inferTypeArgument(target.getClass, genericType.asInstanceOf[TypeVariable[_ <: GenericDeclaration]])
          if (typeArgument != null) return new EvaluationResult(value, typeArgument)
        }
    }
    if(value == null)
      new EvaluationResult(value, valueClass)
    else
      new EvaluationResult(value, value.getClass)
  }

  override def visitFunctionOperatorNode(node: FunctionOperatorNode, p: Void): EvaluationResult = {
    val collector = new ParameterCollector()
    val collection = collector.collect(node.getParametersNode)
    val location = node.getLocation
    if(node.getExpression.startsWith("@")) {
      val targetClass = expressionFunctions.getClass
      val method = findMethod(node.getMethodName, expressionFunctions, targetClass, collection.getParamTypes)
      if (method == null) {
        val signature = MethodUtil.createSignature(node.getMethodName, collection.getParamTypes)
        throw new ExpressionException(Message.DOMA3028, location.getExpression, Integer.valueOf(location.getPosition), signature)
      }
      invokeMethod(node.getLocation, method, expressionFunctions, targetClass, collection.getParamTypes, collection.getParams)
    } else { // Domala add
      val value = variableValues.get(node.getMethodName)
      if (value != null) {
        val method = findMethod("apply", value.getValue, value.getType, collection.getParamTypes)
        if (method != null)
          return invokeMethod(location, method, value.getValue, value.getType, collection.getParamTypes, collection.getParams)
      }
      val signature = MethodUtil.createSignature(node.getMethodName, collection.getParamTypes)
      throw new ExpressionException(Message.DOMA3028, location.getExpression, Integer.valueOf(location.getPosition), signature)
    }
  }

  override protected def calculateHierarchyDifference(paramType: Class[_], argType: Class[_], initDifference: Int): Int = {
    var difference = initDifference
    if (paramType == classOf[Any] && argType.isInterface) return Integer.MAX_VALUE
    var tpe = argType
    while ( {tpe != null}) {
      if (paramType == tpe || paramType == ClassUtil.toBoxedPrimitiveTypeIfPossible(tpe)) return difference
      difference += 1
      if (paramType.isInterface) for (interfaceClass <- tpe.getInterfaces) {
        val result = calculateHierarchyDifference(paramType, interfaceClass, difference)
        if (result != -1) return result
      }
      tpe = tpe.getSuperclass
    }
    -1
  }

  protected class ParameterCollector extends ExpressionNodeVisitor[Void, java.util.List[EvaluationResult]] {
    def collect(node: ExpressionNode): org.seasar.doma.internal.expr.ExpressionEvaluator.ParameterCollection = {
      val evaluationResults = new java.util.ArrayList[EvaluationResult]
      node.accept(this, evaluationResults)
      new org.seasar.doma.internal.expr.ExpressionEvaluator.ParameterCollection(evaluationResults)
    }

    override def visitEqOperatorNode(node: EqOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitNeOperatorNode(node: NeOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitGeOperatorNode(node: GeOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitGtOperatorNode(node: GtOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitLeOperatorNode(node: LeOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitLtOperatorNode(node: LtOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitCommaOperatorNode(node: CommaOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      node.getNodes.forEach(expressionNode => expressionNode.accept(this, p))
      null
    }

    override def visitLiteralNode(node: LiteralNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitVariableNode(node: VariableNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitOrOperatorNode(node: OrOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitAndOperatorNode(node: AndOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitNotOperatorNode(node: NotOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitAddOperatorNode(node: AddOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitSubtractOperatorNode(node: SubtractOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitMultiplyOperatorNode(node: MultiplyOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitDivideOperatorNode(node: DivideOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitModOperatorNode(node: ModOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitNewOperatorNode(node: NewOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitMethodOperatorNode(node: MethodOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitStaticMethodOperatorNode(node: StaticMethodOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitFunctionOperatorNode(node: FunctionOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitFieldOperatorNode(node: FieldOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitStaticFieldOperatorNode(node: StaticFieldOperatorNode, p: java.util.List[EvaluationResult]): Void = {
      evaluate(node, p)
      null
    }

    override def visitParensNode(node: ParensNode, p: java.util.List[EvaluationResult]): Void = {
      node.getNode.accept(this, p)
      null
    }

    override def visitEmptyNode(node: EmptyNode, p: java.util.List[EvaluationResult]): Void = null

    protected def evaluate(node: ExpressionNode, p: java.util.List[EvaluationResult]): Unit = {
      val evaluationResult = evaluateInternal(node)
      p.add(evaluationResult)
    }
  }
}


text:
package petclinic.selenium;

import org.openqa.selenium.WebElement;

import com.github.thomasfischl.rayden.api.RaydenExpressionLocator;
import com.github.thomasfischl.rayden.api.RaydenReporter;
import com.github.thomasfischl.rayden.api.keywords.KeywordResult;
import com.github.thomasfischl.rayden.api.keywords.KeywordScope;
import com.github.thomasfischl.rayden.api.keywords.ScriptedKeyword;

public class TypeTextKeyword implements ScriptedKeyword {

  @Override
  public KeywordResult execute(String keyword, KeywordScope scope, RaydenReporter reporter) {

    RaydenExpressionLocator locator = (RaydenExpressionLocator) scope.getVariable("locator");
    String text = scope.getVariableAsString("text");

    reporter.log("locator:" + locator);
    reporter.log("text:" + text);

    WebElement element = Selenium.getInstance().findElement(locator.getEvalLocator());
    element.sendKeys(text);
    reporter.log("Type Text '" + text + "' to locator " + locator.getEvalLocator() + "'");

    return new KeywordResult(true);
  }
}


text:
{% load i18n horizon humanize %}

{% trans "Description:" %}

{% blocktrans %}
   Volumes are block devices that can be attached to instances.
   {% endblocktrans %}

{% trans "Volume Type Description:" %}

{% block head %}{% trans "Volume Limits" %}{% endblock %}

    {% trans "Total Gigabytes" %} ({% block gigabytes_used %}{{ usages.gigabytesUsed|intcomma }}{% endblock %} {% trans "GB" %})

{{ usages.maxTotalVolumeGigabytes|intcomma|quota:_("GB") }}

    {% block type_title %}{% trans "Number of Volumes" %}{% endblock %} ({% block used %}{{ usages.volumesUsed|intcomma }}{% endblock %})

{% block total %}{{ usages.maxTotalVolumes|intcomma|quota }}{% endblock %}


text:
from flask import Flask
from flask.templating import render_template
from test.simple_controller import simple

app = Flask(__name__)
app.register_blueprint(simple)

@app.route("/", methods=['POST', 'GET'])
def index():
    return 'Hello simple'

if __name__ == "__main__":
    app.run()


text:
var NS = {
  live_label: document.getElementById('live_label'),
  play_label: document.getElementById('play_label'),
  play_button: document.getElementById('play_button'),
  playing: false,
  toggle: function() {
    if (NS.playing) {
      NS.stream.pause();
      NS.playing = false;
      NS.play_button.classList.remove('active');
      NS.live_label.classList.remove('show');
    } else {
      if (!NS.stream) {
        NS.stream = new Audio('https://ni4ce-stream.com/live');
      }
      NS.stream.play();
      NS.playing = true;
      NS.play_button.classList.add('active');
      NS.play_label.classList.remove('show');
      NS.live_label.classList.add('show');
    }
  },
};

play_button.addEventListener('click', NS.toggle);

setTimeout(function(){
  if (!NS.playing)
    NS.play_label.classList.add('show');
}, 2500);


text:
@class MBProductModel;

typedef void(^MBHomePageViewDiscountCellTapBlock)(MBProductModel *model);

@interface MBHomePageViewDiscountCell : TTXBaseTableViewCell
@property (nonatomic, copy) MBHomePageViewDiscountCellTapBlock tapBlock;
+ (CGFloat)cellHeightWithModel:(id)model;
@end


text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/appengine/v1/service.proto

#ifndef PROTOBUF_google_2fappengine_2fv1_2fservice_2eproto__INCLUDED
#define PROTOBUF_google_2fappengine_2fv1_2fservice_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3001000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/map.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "google/api/annotations.pb.h"
// @@protoc_insertion_point(includes)

namespace google {
namespace appengine {
namespace v1 {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_google_2fappengine_2fv1_2fservice_2eproto();
void protobuf_InitDefaults_google_2fappengine_2fv1_2fservice_2eproto();
void protobuf_AssignDesc_google_2fappengine_2fv1_2fservice_2eproto();
void protobuf_ShutdownFile_google_2fappengine_2fv1_2fservice_2eproto();

class Service;
class TrafficSplit;

enum TrafficSplit_ShardBy {
  TrafficSplit_ShardBy_UNSPECIFIED = 0,
  TrafficSplit_ShardBy_COOKIE = 1,
  TrafficSplit_ShardBy_IP = 2,
  TrafficSplit_ShardBy_TrafficSplit_ShardBy_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  TrafficSplit_ShardBy_TrafficSplit_ShardBy_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool TrafficSplit_ShardBy_IsValid(int value);
const TrafficSplit_ShardBy TrafficSplit_ShardBy_ShardBy_MIN = TrafficSplit_ShardBy_UNSPECIFIED;
const TrafficSplit_ShardBy TrafficSplit_ShardBy_ShardBy_MAX = TrafficSplit_ShardBy_IP;
const int TrafficSplit_ShardBy_ShardBy_ARRAYSIZE = TrafficSplit_ShardBy_ShardBy_MAX + 1;

const ::google::protobuf::EnumDescriptor* TrafficSplit_ShardBy_descriptor();
inline const ::std::string& TrafficSplit_ShardBy_Name(TrafficSplit_ShardBy value) {
  return ::google::protobuf::internal::NameOfEnum(
    TrafficSplit_ShardBy_descriptor(), value);
}
inline bool TrafficSplit_ShardBy_Parse(
    const ::std::string& name, TrafficSplit_ShardBy* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TrafficSplit_ShardBy>(
    TrafficSplit_ShardBy_descriptor(), name, value);
}
// ===================================================================

class Service : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.appengine.v1.Service) */ {
 public:
  Service();
  virtual ~Service();

  Service(const Service& from);

  inline Service& operator=(const Service& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Service& default_instance();

  static const Service* internal_default_instance();

  void Swap(Service* other);

  // implements Message ----------------------------------------------

  inline Service* New() const { return New(NULL); }

  Service* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Service& from);
  void MergeFrom(const Service& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Service* other);
  void UnsafeMergeFrom(const Service& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // optional string id = 2;
  void clear_id();
  static const int kIdFieldNumber = 2;
  const ::std::string& id() const;
  void set_id(const ::std::string& value);
  void set_id(const char* value);
  void set_id(const char* value, size_t size);
  ::std::string* mutable_id();
  ::std::string* release_id();
  void set_allocated_id(::std::string* id);

  // optional .google.appengine.v1.TrafficSplit split = 3;
  bool has_split() const;
  void clear_split();
  static const int kSplitFieldNumber = 3;
  const ::google::appengine::v1::TrafficSplit& split() const;
  ::google::appengine::v1::TrafficSplit* mutable_split();
  ::google::appengine::v1::TrafficSplit* release_split();
  void set_allocated_split(::google::appengine::v1::TrafficSplit* split);

  // @@protoc_insertion_point(class_scope:google.appengine.v1.Service)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr id_;
  ::google::appengine::v1::TrafficSplit* split_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_google_2fappengine_2fv1_2fservice_2eproto_impl();
  friend void  protobuf_AddDesc_google_2fappengine_2fv1_2fservice_2eproto_impl();
  friend void protobuf_AssignDesc_google_2fappengine_2fv1_2fservice_2eproto();
  friend void protobuf_ShutdownFile_google_2fappengine_2fv1_2fservice_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<Service> Service_default_instance_;

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

class TrafficSplit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.appengine.v1.TrafficSplit) */ {
 public:
  TrafficSplit();
  virtual ~TrafficSplit();

  TrafficSplit(const TrafficSplit& from);

  inline TrafficSplit& operator=(const TrafficSplit& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TrafficSplit& default_instance();

  static const TrafficSplit* internal_default_instance();

  void Swap(TrafficSplit* other);

  // implements Message ----------------------------------------------

  inline TrafficSplit* New() const { return New(NULL); }

  TrafficSplit* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TrafficSplit& from);
  void MergeFrom(const TrafficSplit& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TrafficSplit* other);
  void UnsafeMergeFrom(const TrafficSplit& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef TrafficSplit_ShardBy ShardBy;
  static const ShardBy UNSPECIFIED =
    TrafficSplit_ShardBy_UNSPECIFIED;
  static const ShardBy COOKIE =
    TrafficSplit_ShardBy_COOKIE;
  static const ShardBy IP =
    TrafficSplit_ShardBy_IP;
  static inline bool ShardBy_IsValid(int value) {
    return TrafficSplit_ShardBy_IsValid(value);
  }
  static const ShardBy ShardBy_MIN =
    TrafficSplit_ShardBy_ShardBy_MIN;
  static const ShardBy ShardBy_MAX =
    TrafficSplit_ShardBy_ShardBy_MAX;
  static const int ShardBy_ARRAYSIZE =
    TrafficSplit_ShardBy_ShardBy_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ShardBy_descriptor() {
    return TrafficSplit_ShardBy_descriptor();
  }
  static inline const ::std::string& ShardBy_Name(ShardBy value) {
    return TrafficSplit_ShardBy_Name(value);
  }
  static inline bool ShardBy_Parse(const ::std::string& name,
      ShardBy* value) {
    return TrafficSplit_ShardBy_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional .google.appengine.v1.TrafficSplit.ShardBy shard_by = 1;
  void clear_shard_by();
  static const int kShardByFieldNumber = 1;
  ::google::appengine::v1::TrafficSplit_ShardBy shard_by() const;
  void set_shard_by(::google::appengine::v1::TrafficSplit_ShardBy value);

  // map<string, double> allocations = 2;
  int allocations_size() const;
  void clear_allocations();
  static const int kAllocationsFieldNumber = 2;
  const ::google::protobuf::Map< ::std::string, double >&
      allocations() const;
  ::google::protobuf::Map< ::std::string, double >*
      mutable_allocations();

  // @@protoc_insertion_point(class_scope:google.appengine.v1.TrafficSplit)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  typedef ::google::protobuf::internal::MapEntryLite<
      ::std::string, double,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE,
      0 >
      TrafficSplit_AllocationsEntry;
  ::google::protobuf::internal::MapField<
      ::std::string, double,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE,
      0 > allocations_;
  int shard_by_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_google_2fappengine_2fv1_2fservice_2eproto_impl();
  friend void  protobuf_AddDesc_google_2fappengine_2fv1_2fservice_2eproto_impl();
  friend void protobuf_AssignDesc_google_2fappengine_2fv1_2fservice_2eproto();
  friend void protobuf_ShutdownFile_google_2fappengine_2fv1_2fservice_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<TrafficSplit> TrafficSplit_default_instance_;

// ===================================================================

// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// Service

// optional string name = 1;
inline void Service::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Service::name() const {
  // @@protoc_insertion_point(field_get:google.appengine.v1.Service.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Service::set_name(const ::std::string& value) {

  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.appengine.v1.Service.name)
}
inline void Service::set_name(const char* value) {

  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.appengine.v1.Service.name)
}
inline void Service::set_name(const char* value, size_t size) {

  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.appengine.v1.Service.name)
}
inline ::std::string* Service::mutable_name() {

  // @@protoc_insertion_point(field_mutable:google.appengine.v1.Service.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Service::release_name() {
  // @@protoc_insertion_point(field_release:google.appengine.v1.Service.name)

  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Service::set_allocated_name(::std::string* name) {
  if (name != NULL) {

  } else {

  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:google.appengine.v1.Service.name)
}

// optional string id = 2;
inline void Service::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Service::id() const {
  // @@protoc_insertion_point(field_get:google.appengine.v1.Service.id)
  return id_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Service::set_id(const ::std::string& value) {

  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.appengine.v1.Service.id)
}
inline void Service::set_id(const char* value) {

  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.appengine.v1.Service.id)
}
inline void Service::set_id(const char* value, size_t size) {

  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.appengine.v1.Service.id)
}
inline ::std::string* Service::mutable_id() {

  // @@protoc_insertion_point(field_mutable:google.appengine.v1.Service.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Service::release_id() {
  // @@protoc_insertion_point(field_release:google.appengine.v1.Service.id)

  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Service::set_allocated_id(::std::string* id) {
  if (id != NULL) {

  } else {

  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:google.appengine.v1.Service.id)
}

// optional .google.appengine.v1.TrafficSplit split = 3;
inline bool Service::has_split() const {
  return this != internal_default_instance() && split_ != NULL;
}
inline void Service::clear_split() {
  if (GetArenaNoVirtual() == NULL && split_ != NULL) delete split_;
  split_ = NULL;
}
inline const ::google::appengine::v1::TrafficSplit& Service::split() const {
  // @@protoc_insertion_point(field_get:google.appengine.v1.Service.split)
  return split_ != NULL ? *split_
                         : *::google::appengine::v1::TrafficSplit::internal_default_instance();
}
inline ::google::appengine::v1::TrafficSplit* Service::mutable_split() {

  if (split_ == NULL) {
    split_ = new ::google::appengine::v1::TrafficSplit;
  }
  // @@protoc_insertion_point(field_mutable:google.appengine.v1.Service.split)
  return split_;
}
inline ::google::appengine::v1::TrafficSplit* Service::release_split() {
  // @@protoc_insertion_point(field_release:google.appengine.v1.Service.split)

  ::google::appengine::v1::TrafficSplit* temp = split_;
  split_ = NULL;
  return temp;
}
inline void Service::set_allocated_split(::google::appengine::v1::TrafficSplit* split) {
  delete split_;
  split_ = split;
  if (split) {

  } else {

  }
  // @@protoc_insertion_point(field_set_allocated:google.appengine.v1.Service.split)
}

inline const Service* Service::internal_default_instance() {
  return &Service_default_instance_.get();
}
// -------------------------------------------------------------------

// TrafficSplit

// optional .google.appengine.v1.TrafficSplit.ShardBy shard_by = 1;
inline void TrafficSplit::clear_shard_by() {
  shard_by_ = 0;
}
inline ::google::appengine::v1::TrafficSplit_ShardBy TrafficSplit::shard_by() const {
  // @@protoc_insertion_point(field_get:google.appengine.v1.TrafficSplit.shard_by)
  return static_cast< ::google::appengine::v1::TrafficSplit_ShardBy >(shard_by_);
}
inline void TrafficSplit::set_shard_by(::google::appengine::v1::TrafficSplit_ShardBy value) {

  shard_by_ = value;
  // @@protoc_insertion_point(field_set:google.appengine.v1.TrafficSplit.shard_by)
}

// map<string, double> allocations = 2;
inline int TrafficSplit::allocations_size() const {
  return allocations_.size();
}
inline void TrafficSplit::clear_allocations() {
  allocations_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, double >&
TrafficSplit::allocations() const {
  // @@protoc_insertion_point(field_map:google.appengine.v1.TrafficSplit.allocations)
  return allocations_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, double >*
TrafficSplit::mutable_allocations() {
  // @@protoc_insertion_point(field_mutable_map:google.appengine.v1.TrafficSplit.allocations)
  return allocations_.MutableMap();
}

inline const TrafficSplit* TrafficSplit::internal_default_instance() {
  return &TrafficSplit_default_instance_.get();
}
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace appengine
}  // namespace google

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::google::appengine::v1::TrafficSplit_ShardBy> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::google::appengine::v1::TrafficSplit_ShardBy>() {
  return ::google::appengine::v1::TrafficSplit_ShardBy_descriptor();
}

}  // namespace protobuf
}  // namespace google
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_google_2fappengine_2fv1_2fservice_2eproto__INCLUDED


text:
Security Hacktoolkit
====================

Placeholder


text:
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

namespace Tweaker.UI
{
	public class InspectorToggleGroupView : MonoBehaviour, IInspectorContentView
	{
		public ToggleGroup ToggleGroup;

		public void Awake()
		{

		}

		public void DestroySelf()
		{
			Destroy(gameObject);
		}

		public void Destroy()
		{

		}
	}
}


text:
package langusta3.sk;

import java.util.ArrayList;
import java.util.List;
import langusta3.core.Alphabet;
import langusta3.core.SpelledWord;

/**
 *
 * @author marx
 */
public class LemmaSpeller extends DzChSpeller {
    public LemmaSpeller(Alphabet alphabet) {
        super(alphabet);
    }

    @Override
    public List<SpelledWord> wordSpelling(String word) {
        List<SpelledWord> superResult = super.wordSpelling(word);
        List<SpelledWord> result = new ArrayList<SpelledWord>();

        for (SpelledWord s : superResult) {
            boolean accept = true;

            for (int i = s.size() - 2; i > 0; i--) {
                if (s.get(i).toString().equals("i") && s.get(i + 1).toString().equals("a") && ( i + 2 != s.size())) {
                    accept = false;
                } else if (s.get(i).toString().equals("i") && s.get(i + 1).toString().equals("e") && ( i + 2 != s.size())) {
                    accept = false;
                } else if (s.get(i).toString().equals("i") && s.get(i + 1).toString().equals("u") && ( i + 2 != s.size())) {
                    accept = false;
                }
            }

            if (accept) {
                result.add(s);
            }
        }

        return result;
    }

}