text:
//$Id: Baz.java 4688 2004-10-26 09:10:50Z oneovthafew $
package org.hibernate.test.legacy;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

public class Baz implements Named, Serializable, Comparable {
	private SortedSet stringSet;
	private Map stringDateMap;
	private List stringList;
	private int[] intArray;
	private FooProxy[] fooArray;
	private String[] stringArray;
	private String code;
	private List customs;
	private List topComponents;
	private Set fooSet;
	private FooComponent[] components;
	private Date[] timeArray;
	private int count;
	private String name;
	private Collection bag;
	private Set topFoos;
	private Map topGlarchez;
	private Set cascadingBars;
	private Map fooToGlarch;
	private Map fooComponentToFoo;
	private Map glarchToFoo;
	private List fees;
	private Collection fooBag;
	private Set cached;
	private Map cachedMap;
	private Map stringGlarchMap;
	private Map anyToAny;
	private List manyToAny;
	private Collection idFooBag;
	private Collection byteBag;
	private FooProxy foo;
	private List bazez;
	private SortedSet sortablez;
	private NestingComponent collectionComponent;
	private String text;
	private List parts;
	private List moreParts;
	public List subs;
	public Baz superBaz;

	Baz() {}

	public SortedSet getStringSet() {
		return stringSet;
	}
	public void setStringSet(SortedSet stringSet) {
		this.stringSet = stringSet;
	}
	public Map getStringDateMap() {
		return stringDateMap;
	}
	public void setStringDateMap(Map stringDateMap) {
		this.stringDateMap = stringDateMap;
	}
	public List getStringList() {
		return stringList;
	}
	public void setStringList(List stringList) {
		this.stringList = stringList;
	}
	public int[] getIntArray() {
		return intArray;
	}
	public void setIntArray(int[] intArray) {
		this.intArray = intArray;
	}
	public FooProxy[] getFooArray() {
		return fooArray;
	}
	public void setFooArray(FooProxy[] fooArray) {
		this.fooArray = fooArray;
	}
	public String[] getStringArray() {
		return stringArray;
	}
	public void setStringArray(String[] stringArray) {
		this.stringArray = stringArray;
	}

	public String getCode() {
		return code;
	}
	public void setCode(String code) {
		this.code = code;
	}

	public void setDefaults() {
		SortedSet set = new TreeSet();
		set.add("foo"); set.add("bar"); set.add("baz");
		setStringSet(set);
		Map map = new TreeMap();
		map.put( "now", new Date() );
		map.put( "never", null );
		map.put( "big bang", new Date(0) );
		setStringDateMap(map);
		List list = new ArrayList();
		list.addAll(set);
		setStringList(list);
		setIntArray( new int[] { 1,3,3,7 } );
		setFooArray( new Foo[0] );
		setStringArray( (String[]) list.toArray( new String[0] ) );
		customs = new ArrayList();
		customs.add( new String[] { "foo", "bar" } );
		customs.add( new String[] { "A", "B" } );
		customs.add( new String[] { "1", "2" } );

		fooSet = new HashSet();
		components = new FooComponent[] {
			new FooComponent("foo", 42, null, null),
			new FooComponent("bar", 88, null, new FooComponent("sub", 69, null, null) )
		};
		timeArray = new Date[] { new Date(), new Date(), null, new Date(0) };
		TreeSet x = new TreeSet();
		x.add("w"); x.add("x"); x.add("y"); x.add("z");
		TreeSet a = new TreeSet();
		a.add("a"); a.add("b"); a.add("d"); a.add("c");

		count = 667;
		name="Bazza";
		topComponents = new ArrayList();
		topComponents.add( new FooComponent("foo", 11, new Date[] { new Date(), new Date(123) }, null) );
		topComponents.add( new FooComponent("bar", 22, new Date[] { new Date(7), new Date(456) }, null) );
		topComponents.add( null );
		bag = new ArrayList();
		bag.add("duplicate");
		bag.add("duplicate");
		bag.add("duplicate");
		bag.add("unique");
		cached = new TreeSet();
		CompositeElement ce = new CompositeElement();
		ce.setFoo("foo");
		ce.setBar("bar");
		CompositeElement ce2 = new CompositeElement();
		ce2.setFoo("fooxxx");
		ce2.setBar("barxxx");
		cached.add(ce);
		cached.add(ce2);
		cachedMap = new TreeMap();
		cachedMap.put(this, ce);

		text="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
		for (int i=0; i<10; i++) text+=text;

	}

	public List getCustoms() {
		return customs;
	}
	public void setCustoms(List customs) {
		this.customs = customs;
	}

	public Set getFooSet() {
		return fooSet;
	}
	public void setFooSet(Set fooSet) {
		this.fooSet = fooSet;
	}

	public FooComponent[] getComponents() {
		return components;
	}
	public void setComponents(FooComponent[] components) {
		this.components = components;
	}

	public Date[] getTimeArray() {
		return timeArray;
	}

	public void setTimeArray(Date[] timeArray) {
		this.timeArray = timeArray;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List getTopComponents() {
		return topComponents;
	}

	public void setTopComponents(List topComponents) {
		this.topComponents = topComponents;
	}

	public Collection getBag() {
		return bag;
	}

	public void setBag(Collection bag) {
		this.bag = bag;
	}

	public Set getTopFoos() {
		return topFoos;
	}

	public void setTopFoos(Set topFoos) {
		this.topFoos = topFoos;
	}

	public Map getTopGlarchez() {
		return topGlarchez;
	}

	public void setTopGlarchez(Map topGlarchez) {
		this.topGlarchez = topGlarchez;
	}

	public Set getCascadingBars() {
		return cascadingBars;
	}

	public void setCascadingBars(Set cascadingBars) {
		this.cascadingBars = cascadingBars;
	}

	public Map getFooToGlarch() {
		return fooToGlarch;
	}

	public void setFooToGlarch(Map fooToGlarch) {
		this.fooToGlarch = fooToGlarch;
	}

	public Map getFooComponentToFoo() {
		return fooComponentToFoo;
	}

	public void setFooComponentToFoo(Map fooComponentToFoo) {
		this.fooComponentToFoo = fooComponentToFoo;
	}

	public Map getGlarchToFoo() {
		return glarchToFoo;
	}

	public void setGlarchToFoo(Map glarchToFoo) {
		this.glarchToFoo = glarchToFoo;
	}

	public List getFees() {
		return fees;
	}

	public void setFees(List fees) {
		this.fees = fees;
	}

	public Collection getFooBag() {
		return fooBag;
	}

	public void setFooBag(Collection fooBag) {
		this.fooBag = fooBag;
	}

	/**
	 * Returns the cached.
	 * @return Set
	 */
	public Set getCached() {
		return cached;
	}

	/**
	 * Sets the cached.
	 * @param cached The cached to set
	 */
	public void setCached(Set cached) {
		this.cached = cached;
	}

	/**
	 * Returns the cachedMap.
	 * @return Map
	 */
	public Map getCachedMap() {
		return cachedMap;
	}

	/**
	 * Sets the cachedMap.
	 * @param cachedMap The cachedMap to set
	 */
	public void setCachedMap(Map cachedMap) {
		this.cachedMap = cachedMap;
	}

	/**
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	public int compareTo(Object o) {
		return ( (Baz) o ).code.compareTo(code);
	}

	/**
	 * Returns the stringGlarchMap.
	 * @return Map
	 */
	public Map getStringGlarchMap() {
		return stringGlarchMap;
	}

	/**
	 * Sets the stringGlarchMap.
	 * @param stringGlarchMap The stringGlarchMap to set
	 */
	public void setStringGlarchMap(Map stringGlarchMap) {
		this.stringGlarchMap = stringGlarchMap;
	}

	/**
	 * Returns the anyToAny.
	 * @return Map
	 */
	public Map getAnyToAny() {
		return anyToAny;
	}

	/**
	 * Sets the anyToAny.
	 * @param anyToAny The anyToAny to set
	 */
	public void setAnyToAny(Map anyToAny) {
		this.anyToAny = anyToAny;
	}

	public Collection getIdFooBag() {
		return idFooBag;
	}

	public void setIdFooBag(Collection collection) {
		idFooBag = collection;
	}

	public Collection getByteBag() {
		return byteBag;
	}

	public void setByteBag(Collection list) {
		byteBag = list;
	}

	public FooProxy getFoo() {
		return foo;
	}

	public void setFoo(FooProxy foo) {
		this.foo = foo;
	}

	public List getBazez() {
		return bazez;
	}

	public void setBazez(List list) {
		bazez = list;
	}

	public SortedSet getSortablez() {
		return sortablez;
	}

	public void setSortablez(SortedSet set) {
		sortablez = set;
	}

	public NestingComponent getCollectionComponent() {
		return collectionComponent;
	}

	public void setCollectionComponent(NestingComponent collection) {
		collectionComponent = collection;
	}

	/**
	 * @return
	 */
	public String getText() {
		return text;
	}

	/**
	 * @param string
	 */
	public void setText(String string) {
		text = string;
	}

	public List getParts() {
		return parts;
	}

	public void setParts(List list) {
		parts = list;
	}

	public List getManyToAny() {
		return manyToAny;
	}

	public void setManyToAny(List manyToAny) {
		this.manyToAny = manyToAny;
	}

	public List getMoreParts() {
		return moreParts;
	}
	public void setMoreParts(List moreParts) {
		this.moreParts = moreParts;
	}
}


text:
require "test_helper"

# Single Name model test.
class NamesAreSetFromServiceTest < ActiveSupport::TestCase
  setup do
    stub_request(:get, %r{#{address}[0-9]{8,}/api/name-strings})
      .with(headers: { "Accept" => "text/json",
                       "Accept-Encoding" =>
                       "gzip;q=1.0,deflate;q=0.6,identity;q=0.3",
                       "User-Agent" => "Ruby" })
      .to_return(status: 200, body: '{ "class": "silly name class",
    "_links": {
        "permalink": [ ]
    },
    "name_element": "redundant name element for id 91755",
    "action": "unnecessary action",
    "result": {
        "fullMarkedUpName": "full marked up name for id 91755",
        "simpleMarkedUpName": "simple marked up name for id 91755",
        "fullName": "full name for id 91755",
        "simpleName": "simple name for id 91755"
    } }', headers: {})
  end

  def address
    "http://localhost:9090/nsl/services/rest/name/apni/"
  end

  test "names are set from service" do
    name = names(:without_names_from_service)
    assert name.full_name.blank?,
           "This test needs to start with a blank full_name."
    assert name.full_name_html.blank?,
           "This test needs to start with a blank full_name_html."
    assert name.simple_name.blank?,
           "This test needs to start with a blank simple_name."
    assert name.simple_name_html.blank?,
           "This test needs to start with a blank simple_name_html."

    name.set_names!
    assert name.full_name.present?, "Full_name should now be populated."
    assert name.full_name_html.present?,
           "Full_name_html should now be populated."
    assert name.simple_name.present?, "Simple_name should now be populated."
    assert name.simple_name_html.present?,
           "Simple_name_html should now be populated."
  end
end

redpajama_set_name: RedPajamaGithub


text:
package main

// #include<relic.h>
/*
#define ZERO_C	0
#define ONE_C		1
*/
import "C"

/***
 * core.go contains the set of functions required to instantiate the library.
 * These set of functions should be the first called in a project.
 * RELIC maintains a global ctx_t struct to implement many functions across the board (e.g. TRY/CATCH), this struct is instantiated with core_init.
 * The parameters to be used in a context, are set with the param_set family of functions.
 * In this case, we are using the default ep_param_set_any for parameters in elliptic curves over prime fields.
 * The default security level (i.e. type of curve) is set in the makefile before compilation, but it can also be undef'd and redef'd.
 * For a more comprehensive list of methods and available curves, check out relic_ep_param.c
 * NOTE: ZERO_C and ONE_C are defined to make error checking easier and less error-prone, by doing C to C int comparisons.
 * It would be interesting to define a Go struct with the most important data from ctx_t to facilitate access to info such as size of integers, size of primes, curves, etc.
 ***/

//CoreInit initializes the library. Returns a flag with success/error.
//Found in relic_core.c
func coreInit() int {
	if C.core_init() != C.STS_OK {
		C.core_clean()
		return StsErr
	}
	return StsOk
}

//CoreClean finalizes the library. Returns a flag with success/error.
//Found in relic_core.c
func coreClean() int {
	if C.core_clean() != C.STS_OK {
		return StsErr
	}
	return StsOk
}

//EpParamSetAny configure some set of curve parameters for the current security level.
//Found in relic_ep_param.c
func epParamSetAny() int {
	if C.ep_param_set_any() != C.STS_OK {
		C.core_clean()
		return StsErr
	}
	return StsOk
}


text:
<?php

namespace CodeIgniter\Cache\Exceptions;

/**
 * Provides a domain-level interface for broad capture
 * of all framework-related exceptions.
 *
 * catch (\CodeIgniter\Cache\Exceptions\ExceptionInterface) { ... }
 *
 * @deprecated 4.1.2
 */
interface ExceptionInterface
{
}


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

<title>jade.content (JADE v4.3.2 API)</title>
<meta name="date" content="2014-03-28">
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Package

Next Package

Frames

No Frames

All Classes

Package jade.content

This
package and its sub-packages contain classes that support the user in creating
and manipulating complex content expressions according to a given content
language and ontology.

See: Description

Interface Summary

Interface
Description

AgentAction

Generic interface to be implemented by classes associated to agent actions
 in an ontology.

Concept

Generic interface to be implemented by classes associated to concepts
 in an ontology.

ContentElement

Interface representing a generic content element, i.e. an
 expression that can be meaningfully used as the content of
 an ACL message.

Predicate

Generic interface to be implemented by classes associated to predicates
 in an ontology.

Term

Interface representing a generic term, i.e. an expression
 identifying a generic entity (abstract or concrete) that "exist"
 in the world and that agents can talk and reason about.

Class Summary

Class
Description

ContentElementList

Utility class to deal with a list of content elements as a
 content element itself.

ContentManager

This class provides all methods to manage the content languages
 and ontologies "known" by a given agent and to fill and extract the
 content of an ACL message according to a given content language and
 ontology.

OntoACLMessage

Utility class that allow using an ACLMessage object
 as an ontological agent action.

OntoAID

Utility class that allow using an AID object
 as an ontological concept.

Exception Summary

Exception
Description

ContentException

Base class for OntologyException and CodecException

Package jade.content Description

This
package and its sub-packages contain classes that support the user in creating
and manipulating complex content expressions according to a given content
language and ontology.<o:p></o:p>

When an agent A communicates with another agent
B, a certain amount of information I is transferred from A to B by means
of an ACL message. Inside the
ACL message, I is represented as a content expression consistent with a
proper content language (e.g. SL) and encoded in a proper format (e.g. string).
Both A and B have their own (possibly different) way of internally representing
I. Taking into account that the way an agent internally represents a
piece information must allow an easy handling of that piece of information, it
is quite clear that the representation used in an ACL content expression is not
suitable for the inside of an agent.<o:p></o:p>

For example the
information that there is a person whose
name is Giovanni and who is 33 years old in an ACL content expression could
be represented as the string<o:p></o:p>

(Person :name
Giovanni :age 33)<o:p></o:p>

Storing this information
inside an agent simply as a string variable is not suitable to handle the
information as e.g. getting the age of Giovanni would require each time to
parse the string.<o:p></o:p>

Considering software
agents written in Java (as JADE agents are), information can conveniently be
represented inside an agent as Java objects. For example representing the above
information about Giovanni as an instance (a Java object) of an
application-specific class <o:p></o:p>

class Person {<o:p></o:p>

      String name;<o:p></o:p>

      int age;<o:p></o:p>

<o:p> </o:p>

      public
String getName() {return name; }<o:p></o:p>

      public
void setName(String n) {name = n; }<o:p></o:p>

      public
int getAge() {return age; }<o:p></o:p>

      public
void setAge(int a) {age =
a; }<o:p></o:p>

      ….<o:p></o:p>

}<o:p></o:p>

initialized with <o:p></o:p>

name = "Giovanni";<o:p></o:p>

age = 33;<o:p></o:p>

would allow to handle it very easily.<o:p></o:p>

<o:p> </o:p>

It is clear however
that, if on the one hand information handling inside an agent is eased, on the
other hand each time agent A sends a piece of information I to agent B, <o:p></o:p>

<![if !supportLists]>1)
<![endif]>A needs to convert his
internal representation of I into the corresponding ACL content
expression representation and B needs to perform the opposite conversion.<o:p></o:p>

<![if !supportLists]>2)
<![endif]>Moreover B
should also perform a number of semantic checks to verify that I is a
meaningful piece of information, i.e. that it complies with the rules (for
instance that the age of Giovanni is actually an integer value) of the ontology
by means of which both A and B ascribe a proper meaning to I.<o:p></o:p>

The classes included in this package and its sub-packages are
designed to automatically perform all the above conversion and check operations,
thus allowing developers manipulating information within their agents as Java
objects (as described above) without the need of any extra work.

<o:p> </o:p>

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Package

Next Package

Frames

No Frames

All Classes

These are the official JADE API. For these API backward compatibility is guaranteed accross JADE versions


text:
<?php

namespace Chromabits\Nucleus\View\Common;

use Chromabits\Nucleus\View\Interfaces\RenderableInterface;
use Chromabits\Nucleus\View\Node;

/**
 * Class TableHeader.
 *
 * @author Eduardo Trujillo <ed@chromabits.com>
 * @package Chromabits\Nucleus\View\Common
 */
class TableHeader extends Node
{
    /**
     * Construct an instance of a Button.
     *
     * @param string[] $attributes
     * @param string|RenderableInterface|string[]|RenderableInterface[] $content
     */
    public function __construct($attributes, $content = '')
    {
        parent::__construct('thead', $attributes, $content);
    }
}