114 /* The ARGBUF struct. */

115 struct argbuf {

116 /* These are the baseclass definitions. */

117 IADDR addr;

118 const IDESC *idesc;

132 ??? SCACHE used to contain more than just argbuf. We could delete the

133 type entirely and always just use ARGBUF, but for future concerns and as

134 a level of abstraction it is left in. */

135

136 struct scache {

2 * apxx_lincons1.hh

3 *

4 * APRON Library / C++ class wrappers

5 *

6 * Copyright (C) Antoine Mine' 2007

35 * reference count).

36 */

37 class lincons1 : public use_malloc {

38

39 protected:

335 lincons1_array(ap_lincons1_array_t& a);

336

337 friend class abstract1;

338

339 public:

75 case ConfigPackage.CLASS_OPTION: {

76 ClassOption classOption = (ClassOption)theEObject;

77 T result = caseClassOption(classOption);

101 case ConfigPackage.ABSTRACT_REFERENCE_OPTION: {

102 AbstractReferenceOption abstractReferenceOption = (AbstractReferenceOption)theEObject;

103 T result = caseAbstractReferenceOption(abstractReferenceOption);

190 * @generated

191 */

192 public T caseClassOption(ClassOption object) {

193 return null;

194 }

235 * @generated

236 */

237 public T caseAbstractReferenceOption(AbstractReferenceOption object) {

238 return null;

239 }

18 import railo.runtime.type.dt.DateTime;

19

20 public abstract class ComponentProProxy implements ComponentPro {

21

22 public abstract ComponentPro getComponentPro();

26 * @see railo.runtime.Component#getJavaAccessClass(railo.commons.lang.types.RefBoolean)

27 */

28 public Class getJavaAccessClass(RefBoolean isNew) throws PageException {

29 return getComponentPro().getJavaAccessClass(isNew);

214 /**

215 * The SecondaryKeyCreator for the SupplierByCity index. This is an

216 * extension of the abstract class TupleSerialKeyCreator, which implements

217 * SecondaryKeyCreator for the case where the data keys are of the format

218 * TupleFormat and the data values are of the format SerialFormat.

253 /**

254 * The SecondaryKeyCreator for the ShipmentByPart index. This is an

255 * extension of the abstract class TupleSerialKeyCreator, which implements

256 * SecondaryKeyCreator for the case where the data keys are of the format

257 * TupleFormat and the data values are of the format SerialFormat.

287 /**

288 * The SecondaryKeyCreator for the ShipmentBySupplier index. This is an

289 * extension of the abstract class TupleSerialKeyCreator, which implements

290 * SecondaryKeyCreator for the case where the data keys are of the format

291 * TupleFormat and the data values are of the format SerialFormat.

8 namespace ConfigurationValidation

9 {

10 public class When_testing_a_dto_with_mismatched_members : NonValidatingSpecBase

11 {

12 public class ModelObject

16 }

17

18 public class ModelDto

19 {

20 public string Foo { get; set; }

483 }

484

485 class ConcreteDest : IAbstractDest

486 {

487 public string DifferentName { get; set; }

6 using System;

7 using System.Linq;

8 using Raven.Abstractions.Indexing;

9 using Raven.Client.Indexes;

10 using Xunit;

12 namespace Raven.Tests.Document

13 {

14 public class Game : RemoteClientTest

15 {

16

339

340

341 public class GameEvent

342 {

343 public string Id

30 @Stateless

31 @Path("usuarios")

32 public class UsuarioFacadeREST extends AbstractFacade<Usuario> {

33

34 @PersistenceContext(unitName = "CalendarioRESTPU")

36

37 public UsuarioFacadeREST() {

38 super(Usuario.class);

39 }

40

3 using Genetibase.NuGenHL7.model.v231.segment;

4 using HL7Exception = Genetibase.NuGenHL7.NuGenHL7Exception;

5 using ModelClassFactory = Genetibase.NuGenHL7.parser.NuGenModelClassFactory;

6 using DefaultModelClassFactory = Genetibase.NuGenHL7.parser.NuGenDefaultModelClassFactory;

7 using AbstractMessage = Genetibase.NuGenHL7.model.AbstractMessage;

8 namespace Genetibase.NuGenHL7.model.v231.message

9 {

25 /// </summary>

26 [Serializable]

27 public class RCL_I06:AbstractMessage

28 {

29 /// <summary> Returns MSH (MSH - message header segment) - creates it if necessary</summary>

250 }

251

252 /// <summary> Creates a new RCL_I06 Group with custom ModelClassFactory.</summary>

253 public RCL_I06(ModelClassFactory factory):base(factory)

3 using System.Text;

4

5 using Raven.Abstractions.Data;

6 using Raven.Database.Plugins;

7 using Raven.Json.Linq;

9 namespace Raven.Bundles.UniqueConstraints

10 {

11 public class UniqueConstraintsPutTrigger : AbstractPutTrigger

12 {

13 public override void AfterPut(string key, RavenJObject document, RavenJObject metadata, Etag etag)

16 import java.util.*;

17

18 public final class ProjectServiceDTO

19 extends AbstractUserOwnedServiceDTO<ProjectDTO, ProjectRepositoryDTO> implements IProjectServiceDTO {

22 import java.util.logging.Logger;

23

24 import net.milkbowl.vault.economy.AbstractEconomy;

25 import net.milkbowl.vault.economy.EconomyResponse;

26 import net.milkbowl.vault.economy.EconomyResponse.ResponseType;

34 import org.bukkit.plugin.Plugin;

35

36 public class Economy_CurrencyCore extends AbstractEconomy {

37

38 private Currency currency;

48 if(currency == null) {

49 Plugin currencyPlugin = plugin.getServer().getPluginManager().getPlugin("CurrencyCore");

50 if(currencyPlugin != null && currencyPlugin.getClass().getName().equals("is.currency.Currency")) {

51 this.currency = (Currency) currencyPlugin;

52 log.info(String.format("[%s][Economy] %s hooked.", plugin.getDescription().getName(), name));

37 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)

38 */

39 class Type extends \Magento\Framework\Model\AbstractModel

40 {

41 /**

87 * @param \Magento\Eav\Model\Entity\StoreFactory $storeFactory

88 * @param \Magento\Framework\Validator\UniversalFactory $universalFactory

89 * @param \Magento\Framework\Model\ResourceModel\AbstractResource $resource

90 * @param \Magento\Framework\Data\Collection\AbstractDb $resourceCollection

99 \Magento\Eav\Model\Entity\StoreFactory $storeFactory,

100 \Magento\Framework\Validator\UniversalFactory $universalFactory,

101 \Magento\Framework\Model\ResourceModel\AbstractResource $resource = null,

102 \Magento\Framework\Data\Collection\AbstractDb $resourceCollection = null,

118 protected function _construct()

119 {

120 $this->_init(\Magento\Eav\Model\ResourceModel\Entity\Type::class);

121 }

122

41 import net.sf.jasperreports.engine.export.ooxml.JRPptxExporter;

42 import net.sf.jasperreports.engine.export.ooxml.JRXlsxExporter;

43 import net.sf.jasperreports.engine.util.AbstractSampleApp;

44 import net.sf.jasperreports.engine.util.JRLoader;

45

49 * @version $Id: ListApp.java 3150 2009-10-23 16:07:06Z lucianc $

50 */

51 public class ListApp extends AbstractSampleApp

52 {

53

24 // import scala.collection.mutable._

25

26 final class Solver (n: Int) {

27 private var countdown = n

28 private var first: String = _

142 }

143

144 final class Board {

145 val cells = boardCells()

146

514 }

515

516 abstract class Cell {

517 var marked = false

518

5 * com/sun/corba/se/PortableActivationIDL/_ActivatorImplBase.java .

6 * Generated by the IDL-to-Java compiler (portable), version "3.2"

7 * from ../../../../src/share/classes/com/sun/corba/se/PortableActivationIDL/activation.idl

8 * Monday, September 24, 2012 12:05:44 PM PDT

9 */

10

11 public abstract class _ActivatorImplBase extends org.omg.CORBA.portable.ObjectImpl

12 implements com.sun.corba.se.PortableActivationIDL.Activator, org.omg.CORBA.portable.InvokeHandler

13 {

286

287

288 } // class _ActivatorImplBase

289

21 import org.eclipse.emf.common.util.EList;

22

23 import org.eclipse.emf.ecore.EClass;

24 import org.eclipse.emf.ecore.InternalEObject;

25

47 * @generated

48 */

49 public class ServiceTypeImpl extends AbstractDescriptionTypeImpl implements ServiceType {

50 /**

51 * The cached value of the '{@link #getKeywords() <em>Keywords</em>}' containment reference list.

152 */

153 @Override

154 protected EClass eStaticClass() {

155 return Wcs10Package.Literals.SERVICE_TYPE;

156 }

31 * A document used to pass into and out of a master.

32 * <p>

33 * This abstract class is intended for providing the standard design for documents

34 * stored in a master.

35 */

36 @PublicSPI

37 @BeanDefinition

38 public abstract class AbstractDocument extends DirectBean

39 implements UniqueIdentifiable, MutableUniqueIdentifiable, ObjectIdentifiable {

40

342 */

343 private final MetaProperty<Instant> _correctionToInstant = DirectMetaProperty.ofReadWrite(

344 this, "correctionToInstant", AbstractDocument.class, Instant.class);

345 /**

346 * The meta-properties.

377 public BeanBuilder<? extends AbstractDocument> builder() {

378 throw new UnsupportedOperationException("AbstractDocument is an abstract class");

379 }

380

56 * @generated

57 */

58 public abstract class ExpandoValueServiceBaseImpl extends PrincipalBean

59 implements ExpandoValueService, IdentifiableBean {

60 /*

61 * NOTE FOR DEVELOPERS:

62 *

63 * Never modify or reference this class directly. Always use {@link com.liferay.portlet.expando.service.ExpandoValueServiceUtil} to access the expando value remote service.

64 */

65

453 }

454

455 @BeanReference(type = ExpandoColumnLocalService.class)

456 protected ExpandoColumnLocalService expandoColumnLocalService;

457 @BeanReference(type = ExpandoColumnService.class)

31 * <li>{@link net.jgsuess.uml14.behavioral_elements.common_behavior.impl.ReceptionImpl#isIsRoot <em>Is Root</em>}</li>

32 * <li>{@link net.jgsuess.uml14.behavioral_elements.common_behavior.impl.ReceptionImpl#isIsLeaf <em>Is Leaf</em>}</li>

33 * <li>{@link net.jgsuess.uml14.behavioral_elements.common_behavior.impl.ReceptionImpl#isIsAbstract <em>Is Abstract</em>}</li>

34 * <li>{@link net.jgsuess.uml14.behavioral_elements.common_behavior.impl.ReceptionImpl#getSignal <em>Signal</em>}</li>

35 * </ul>

225 * @generated

226 */

227 public void setIsAbstract(boolean newIsAbstract) {

228 boolean oldIsAbstract = isAbstract;

229 isAbstract = newIsAbstract;

230 if (eNotificationRequired())

231 eNotify(new ENotificationImpl(this, Notification.SET, Common_behaviorPackage.RECEPTION__IS_ABSTRACT, oldIsAbstract, isAbstract));

232 }

233

415 case Common_behaviorPackage.RECEPTION__IS_ABSTRACT:

416 return isAbstract != IS_ABSTRACT_EDEFAULT;

417 case Common_behaviorPackage.RECEPTION__SIGNAL:

418 return signal != null;

60 public EObject create(EClass eClass) {

61 switch (eClass.getClassifierID()) {

62 case MT4MTPackage.TEST_SUITE: return createTestSuite();

63 case MT4MTPackage.CUSTOMIZABLE_TEST_CASE: return createCustomizableTestCase();

82 case MT4MTPackage.EXTERNAL_ACTION_PARAMETER: return createExternalActionParameter();

83 default:

84 throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");

85 }

86 }

100 case MT4MTPackage.ABSTRACT_TRANSFORMATION_TEST_CASE:

101 return createAbstractTransformationTestCaseFromString(eDataType, initialValue);

102 case MT4MTPackage.IEXTERNAL_ACTION:

103 return createIExternalActionFromString(eDataType, initialValue);

381 * @generated

382 */

383 public AbstractTransformationTestCase createAbstractTransformationTestCaseFromString(EDataType eDataType, String initialValue) {

384 return (AbstractTransformationTestCase)super.createFromString(eDataType, initialValue);

18

19 /**

20 * Abstract implementation of {@code DataPipelineAsync}. Convenient method forms

21 * pass through to the corresponding overload that takes a request object and an

22 * {@code AsyncHandler}, which throws an {@code UnsupportedOperationException}.

23 */

24 public class AbstractDataPipelineAsync extends AbstractDataPipeline implements

25 DataPipelineAsync {

26

27 protected AbstractDataPipelineAsync() {

28 }

29

6 import java.util.ArrayList;

7 import urn.ebay.apis.eBLBaseComponents.PaymentDetailsItemType;

8 import urn.ebay.apis.eBLBaseComponents.AbstractRequestType;

9 import com.paypal.core.SDKUtil;

10

14 * limits: 19 single-byte characters maximum

15 */

16 public class DoAuthorizationRequestType extends AbstractRequestType {

17

18 private static final String nameSpace="urn:ebay:api:PayPalAPI";

20 /// Used to serialize to and deserialize from the Protobuf format.

21 /// </summary>

22 public class Serializer : AbstractSerializer

23 {

24 private readonly Type expectedType;

137 {

138 buildingSerializer = null;

139 if (propertyType.IsSubclassOf(typeof(Enum)))

140 {

141 buildingSerializer = new BuildingSerializer(

2 using Genetibase.NuGenHL7.model;

3 using Genetibase.NuGenHL7.model.v22.datatype;

4 using ModelClassFactory = Genetibase.NuGenHL7.parser.NuGenModelClassFactory;

5 using HL7Exception = Genetibase.NuGenHL7.NuGenHL7Exception;

6 namespace Genetibase.NuGenHL7.model.v22.segment

34 /// If an exception is handled internally, it is logged and null is returned.

35 /// This is not expected to happen - if it does happen this indicates not so much

36 /// an exceptional circumstance as a bug in the code for this class.</p>

37 /// </summary>

38 [Serializable]

39 public class GT1:AbstractSegment

40 {

41 /// <summary> Returns Set ID - guarantor (GT1-1).</summary>

13

14

15 class QgsMapLayerLegend : QObject

16 {

17 %Docstring(signature="appended")

18 The :py:class:`QgsMapLayerLegend` class is abstract interface for implementations

19 of legends for one map layer.

20

84

85

86 class QgsMapLayerLegendUtils

87 {

88 %Docstring(signature="appended")

187 * @throws UnsupportedOperationException this is an unmodifiable collection

188 */

189 public abstract boolean remove(int i);

190

191 /**

215 * @throws UnsupportedOperationException this is an unmodifiable collection

216 */

217 public abstract boolean removeAll(IntCollection c);

218

219 /**

227 * @throws UnsupportedOperationException this is an unmodifiable collection

228 */

229 public abstract boolean retainAll(IntCollection c);

230

231 /**

17 * @author Matteo Beccati <matteo@beccati.com>

18 */

19 class Php4ConstructorFixerTest extends AbstractFixerTestBase

20 {

21 public function testNamespaces()

932 <?php

933

934 abstract class Foo

935 {

936 abstract function Foo();

946 <?php

947

948 abstract class Foo

949 {

950 abstract public function Foo();

28 // Need a mocked object with only dummy methods. It is just needed for construction.

29 // The setter/getter methods do not use this object (for this set of tests).

30 $scopeConfigMock = $this->getMockForAbstractClass('Magento\Framework\App\Config\ScopeConfigInterface');

31

32 /** @var \Magento\Tax\Model\Config */

62 public function testGetCalculationSequence($applyTaxAfterDiscount, $discountTaxIncl, $expectedValue)

63 {

64 $scopeConfigMock = $this->getMockForAbstractClass('Magento\Framework\App\Config\ScopeConfigInterface');

65 $scopeConfigMock->expects(

66 $this->at(0))->method('getValue')->will($this->returnValue($applyTaxAfterDiscount));

97 public function testScopeConfigMethods($method, $path, $configValue, $expectedValue)

98 {

99 $scopeConfigMock = $this->getMockForAbstractClass('Magento\Framework\App\Config\ScopeConfigInterface');

100 $scopeConfigMock->expects($this->once())

101 ->method('getValue')

5 use OAuth\OAuth1\Service\Yahoo;

6

7 class YahooTest extends \PHPUnit_Framework_TestCase

8 {

9 /**

34 );

35

36 $this->assertInstanceOf('\\OAuth\\OAuth1\\Service\\AbstractService', $service);

37 }

38

50 );

51

52 $this->assertInstanceOf('\\OAuth\\OAuth1\\Service\\AbstractService', $service);

53 }

54

31 {

32 /**

33 * Factory for Zend_Barcode classes.

34 *

35 * First argument may be a string containing the base of the adapter class

183 * Create an instance of the barcode class.

184 * Pass the config to the barcode class constructor.

185 */

186 $bcAdapter = new $barcodeName($barcodeConfig);

195 #require_once 'Zend/Barcode/Exception.php';

196 throw new Zend_Barcode_Exception(

197 "Barcode class '$barcodeName' does not extend Zend_Barcode_Object_ObjectAbstract"

198 );

199 }

297 #require_once 'Zend/Barcode/Exception.php';

298 $e = new Zend_Barcode_Exception(

299 "Renderer class '$rendererName' does not extend Zend_Barcode_Renderer_RendererAbstract"

300 );

301 $e->setIsRenderable(false);

44 * @generated

45 */

46 public abstract class BaoCaoDLIServiceBaseImpl extends BaseServiceImpl

47 implements BaoCaoDLIService, IdentifiableBean {

48 /*

331 Thread currentThread = Thread.currentThread();

332

333 ClassLoader contextClassLoader = currentThread.getContextClassLoader();

334

335 if (contextClassLoader != _classLoader) {

401 protected UserPersistence userPersistence;

402 private String _beanIdentifier;

403 private ClassLoader _classLoader;

404 private BaoCaoDLIServiceClpInvoker _clpInvoker = new BaoCaoDLIServiceClpInvoker();

405 }

22

23 /**

24 * @see Zend_View_Helper_Navigation_HelperAbstract

25 */

26 require_once 'Zend/View/Helper/Navigation/HelperAbstract.php';

35 * @license http://framework.zend.com/license/new-bsd New BSD License

36 */

37 class Zend_View_Helper_Navigation

38 extends Zend_View_Helper_Navigation_HelperAbstract

179 'Proxy helper "%s" is not an instance of ' .

180 'Zend_View_Helper_Navigation_Helper',

181 get_class($helper)));

182 $e->setView($this->view);

183 throw $e;

22

23 /**

24 * @see Zend_View_Helper_Navigation_HelperAbstract

25 */

26 require_once 'Zend/View/Helper/Navigation/HelperAbstract.php';

35 * @license http://framework.zend.com/license/new-bsd New BSD License

36 */

37 class Zend_View_Helper_Navigation_Breadcrumbs

38 extends Zend_View_Helper_Navigation_HelperAbstract

17 import cdc.io.data.Element;

18 import cdc.io.data.NodeType;

19 import cdc.io.data.util.AbstractResourceLoader;

20 import cdc.util.lang.FailureReaction;

21

22 public final class DAnalysisXmlLoader extends AbstractResourceLoader<DAnalysis> {

23 private final DAnalysis analysis;

24

363 private static void parseScope(DElement delement,

364 Element element) {

365 final DElementScope scope = element.getAttributeAsEnum(DAnalysisXml.SCOPE, DElementScope.class, DElementScope.UNKNOWN);

366 if (delement instanceof DItem) {

367 ((DItem) delement).setScope(scope);

21 <TABLE BORDER="0" WIDTH="100%" SUMMARY="">

22 <TR>

23 <TD NOWRAP><FONT CLASS="FrameItemFont"><A HREF="edu/udo/cs/wvtool/generic/stemmer/AbstractStemmer.html" title="class in edu.udo.cs.wvtool.generic.stemmer" target="classFrame">AbstractStemmer</A>

24 <BR>

25 <A HREF="edu/udo/cs/wvtool/generic/wordfilter/AbstractStopWordFilter.html" title="class in edu.udo.cs.wvtool.generic.wordfilter" target="classFrame">AbstractStopWordFilter</A>

26 <BR>

27 <A HREF="edu/udo/cs/wvtool/generic/stemmer/AbstractWordNetStemmer.html" title="class in edu.udo.cs.wvtool.generic.stemmer" target="classFrame">AbstractWordNetStemmer</A>

28 <BR>

29 <A HREF="edu/udo/cs/wvtool/generic/vectorcreation/BinaryOccurrences.html" title="class in edu.udo.cs.wvtool.generic.vectorcreation" target="classFrame">BinaryOccurrences</A>

87 <A HREF="edu/udo/cs/wvtool/generic/wordfilter/StopWordsWrapper.html" title="class in edu.udo.cs.wvtool.generic.wordfilter" target="classFrame">StopWordsWrapper</A>

88 <BR>

89 <A HREF="edu/udo/cs/wvtool/generic/wordfilter/StopWordsWrapperGerman.html" title="class in edu.udo.cs.wvtool.generic.wordfilter" target="classFrame">StopWordsWrapperGerman</A>

90 <BR>

91 <A HREF="edu/udo/cs/wvtool/generic/inputfilter/TagIgnoringReader.html" title="class in edu.udo.cs.wvtool.generic.inputfilter" target="classFrame">TagIgnoringReader</A>

277

278 public boolean compareAndSet(T obj, int expect, int update) {

279 if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);

280 return unsafe.compareAndSwapInt(obj, offset, expect, update);

281 }

292

293 public void lazySet(T obj, int newValue) {

294 if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);

295 unsafe.putOrderedInt(obj, offset, newValue);

296 }

297

298 public final int get(T obj) {

299 if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);

300 return unsafe.getIntVolatile(obj, offset);

301 }

144 Class cls;

145 cls = Class.forName(className);

146 xmlReader = (XMLReader) cls.newInstance();

147 if (LOG.isDebugEnabled()) {

159 * to obtain the {@link Class} instance, and uses {@link Class#newInstance()}

160 * to create the actual instance.

161 * @param className The class name of the {@link Parser} instance to be instantiated.

162 * @return An {@link Parser} instance.

163 */

167 Class cls;

168 cls = Class.forName(className);

169 parser = (Parser) cls.newInstance();

170 if (LOG.isDebugEnabled()) {

184 String parserClassName = properties.getString(XMLProperties.PARSER);

185 if ((parserClassName == null) || (parserClassName.length() == 0)) {

186 SAXParser saxParser = XMLParserUtils.getSAXParser(

187 validation.booleanValue(), namespaces.booleanValue());

17 import gatchan.phpparser.parser.PHPParser;

18

19 public final class StringLiteral extends Literal {

20 private String source;

21

22 private AbstractVariable[] variablesInside;

23

24 public StringLiteral(Token token) {

50 int beginColumn,

51 int endColumn,

52 AbstractVariable[] variablesInside) {

53 super(Type.STRING, sourceStart, sourceEnd, beginLine, endLine, beginColumn, endColumn);

54 this.source = source;

153 }

154

155 abstract class PersistentViewSpec(config: Config) extends AkkaSpec(config) with PersistenceSpec with ImplicitSender {

156 import akka.persistence.PersistentViewSpec._

157

183

184 def subscribeToReplay(probe: TestProbe): Unit =

185 system.eventStream.subscribe(probe.ref, classOf[ReplayMessages])

186

187 "A persistent view" must {

199 }

200 "run updates at specified interval" in {

201 view = system.actorOf(Props(classOf[TestPersistentView], name, viewProbe.ref, 2.seconds))

202 // initial update is done on start

203 viewProbe.expectMsg("replicated-a-1")

12 * @link https://bitbucket.org/dlu/dlutwbootstrap

13 */

14 abstract class AbstractHelper extends AbstractZfNavigationHelper

15 {

16 const ALIGN_LEFT = 'left';

171 //Active

172 if($page->isActive(true)) {

173 $liClass = ' class="active"';

174 } else {

175 $liClass = '';

268 }

269 }

270 $icon = '<i class="' . $iClass . '"></i> ';

271 } else {

272 $icon = '';

130 }

131 /**

132 * This class implements SUDescriptor

133 */

134 public static class SUDescriptorImpl implements SUDescriptor {

192 * Base class that implements the Service interface

193 */

194 public static abstract class AbstractService implements Service {

195

196 private QName mInterface;

198 private String mEndpointName;

199

200 private AbstractService() {

201 }

202 /**

24

25 /**

26 * Abstract Finite State Machine

27 *

28 * Take a look on Wikipedia state machine description: http://en.wikipedia.org/wiki/Finite_state_machine

29 *

30 * Any type of Transducers (Moore machine or Mealy machine) also may be implemented by using this abstract FSM.

31 * process() methods invokes a specified actions which may construct FSM output.

32 * Actions may be also used to signal, that we have reached Accept State

37 * @license http://framework.zend.com/license/new-bsd New BSD License

38 */

39 abstract class Zend_Search_Lucene_FSM

40 {

41 /**

19 import static org.hamcrest.Matchers.equalTo;

20

21 public class RollupJobConfigTests extends AbstractSerializingTestCase<RollupJobConfig> {

22

23 private String jobId;

187

188 Exception e = expectThrows(

189 IllegalArgumentException.class,

190 () -> new RollupJobConfig(

191 sample.getId(),

221

222 Exception e = expectThrows(

223 IllegalArgumentException.class,

224 () -> new RollupJobConfig(

225 sample.getId(),

31 boolean testClassPath()

32 {

33 classpath = System.getProperty("java.class.path");

34 classSeparator = (File.separatorChar == '/' ? ':' : ';');

35 return (classpath.indexOf(classSeparator) != -1)

36 || (!classpath.endsWith("jedit.jar"));

52 File getRoot(File file)

53 {

54 tokens = new StringTokenizer(System.getProperty("java.class.path"),

55 File.pathSeparator);

56 fileSet = new Hashtable();

121 displayed if no suitable package name is found. This macro will not

122 work if jEdit is being run as a JAR file without specifying a

123 classpath. In that case the classpath seen by the macro consists

124 solely of the JAR file.

125 </para>

77 var _getAttribute = function(el, attName) { return jsPlumb.CurrentLibrary.getAttribute(_getElementObject(el), attName); },

78 _setAttribute = function(el, attName, attValue) { jsPlumb.CurrentLibrary.setAttribute(_getElementObject(el), attName, attValue); },

79 _addClass = function(el, clazz) { jsPlumb.CurrentLibrary.addClass(_getElementObject(el), clazz); },

80 _hasClass = function(el, clazz) { return jsPlumb.CurrentLibrary.hasClass(_getElementObject(el), clazz); },

81 _removeClass = function(el, clazz) { jsPlumb.CurrentLibrary.removeClass(_getElementObject(el), clazz); },

82 _getElementObject = function(el) { return jsPlumb.CurrentLibrary.getElementObject(el); },

83 _getOffset = function(el) { return jsPlumb.CurrentLibrary.getOffset(_getElementObject(el)); },

159 * Class:jsPlumbUIComponent

160 * Abstract superclass for UI components Endpoint and Connection. Provides the abstraction of paintStyle/hoverPaintStyle,

161 * and also extends EventGenerator to provide the bind and fire methods.

162 */

782 * Property: connectorClass

783 * The CSS class to set on Connection elements. This value is a String and can have multiple classes; the entire String is appended as-is.

784 */

785 this.connectorClass = "_jsPlumb_connector";

61 * </ul><p>

62 * In order to use with a jEdit option pane it is recommended that your option

63 * pane class should override the <code>addComponent</code> method with

64 * something like:

65 * <pre>public void addComponent(PathBuilder comp)

66 * {

67 * GridBagConstraints cons = new GridBagConstraints();

68 * cons.gridy = y++; // y is a protected member of AbstractOptionPane

69 * cons.gridheight = 1;

70 * cons.gridwidth = GridBagConstraints.REMAINDER;

77 * add(comp);

78 * }</pre>

79 * Just using the default <code>AbstractOptionPane.addComponent()</code> method

80 * can result in odd things happening when the option pane is resized.

81 *

40

41

42 public class BibTeXPanel

43 extends AbstractToolPanel {

31 import javax.swing.JTextField;

32

33 import org.gjt.sp.jedit.AbstractOptionPane;

34 import org.gjt.sp.jedit.jEdit;

35

36

37 //}}}

38 public class LaTeXOptionPane

39 extends AbstractOptionPane {

144 classpathField = new JTextField(30);

145 classpathField.setText(jEdit.getProperty("latex.classpath.dirs"));

146 addComponent(classpathField);

163 jEdit.setBooleanProperty("latex.viewoutput.detach",

164 viewerDetach.getModel().isSelected());

165 jEdit.setProperty("latex.classpath.dirs", classpathField.getText());

166 jEdit.setProperty("latex.compile.c-errors", compileShowErrorsSwitch.getText());

167 }

3 * Copyright (C) 2001 Dirk Moebius

4 *

5 * Loosely modelled after AbstractOptionPane.java

6 * Copyright (C) 1998, 1999, 2000, 2001 Slava Pestov

7 *

34

35 /**

36 * An abstract option pane for session properties.

37 * All session option panes must inherit from this class.

38 */

39 public abstract class SessionPropertyPane extends JPanel

40 {

41 /**

55 * eg. "myplugin.sessionproperties.firstPane".

56 */

57 public abstract String getIdentifier();

58

59

26 import javax.swing.JTextPane;

27

28 import org.gjt.sp.jedit.AbstractOptionPane;

29 import org.gjt.sp.jedit.jEdit;

30

32 //}}}

33

34 public class GeneralOptionPane extends AbstractOptionPane

35 {

36 //{{{ Private members

53 * $Id: TrangGUITest.java 21325 2012-03-11 11:03:44Z kerik-sf $

54 */

55 public class TrangGUITest{

56 private static File testData;

57

58 @BeforeClass

59 public static void setUpjEdit() throws IOException{

60 TestUtils.beforeClass();

63 }

64

65 @AfterClass

66 public static void tearDownjEdit() {

67 TestUtils.afterClass();

1 require File.dirname(__FILE__) + '/abstract_unit'

2

3 class ActsAsTaggableOnSteroidsTest < Test::Unit::TestCase

85 end

86

87 def test_basic_tag_counts_on_class

88 assert_tag_counts Post.tag_counts, :good => 2, :nature => 7, :question => 1, :bad => 1

89 assert_tag_counts Photo.tag_counts, :good => 1, :nature => 3, :question => 1, :bad => 1, :animal => 3

90 end

91

92 def test_tag_counts_on_class_with_date_conditions

93 assert_tag_counts Post.tag_counts(:start_at => Date.new(2006, 8, 4)), :good => 1, :nature => 5, :question => 1, :bad => 1

94 assert_tag_counts Post.tag_counts(:end_at => Date.new(2006, 8, 6)), :good => 1, :nature => 4, :question => 1

98 end

99

100 def test_tag_counts_on_class_with_frequencies

101 assert_tag_counts Photo.tag_counts(:at_least => 2), :nature => 3, :animal => 3

102 assert_tag_counts Photo.tag_counts(:at_most => 2), :good => 1, :question => 1, :bad => 1

155 <xs:annotation>

156 <xs:documentation>

157 This is the abstract base class for BiAbstractChart

158 and BiAbstractChart2. All the charts

516 </xs:complexType>

517 </xs:element>

518 <xs:element name="BiAbstractGauge2ScaleSection" substitutionGroup="AbstractGauge2ScaleSection"/>

519

520 <xs:attributeGroup name="AbstractGauge2ScaleSectionAttributes">

537 <xs:element name="AbstractGauge2Ticks">

538 <xs:annotation>

539 <xs:documentation>This class is the base class of all ticks classes

540 </xs:documentation>

541 </xs:annotation>

773 <xs:element name="AbstractLoader">

774 <xs:annotation>

775 <xs:documentation>This abstract class defines the minimal interface for supporting loading

776 </xs:documentation>

777 </xs:annotation>

294 * A list model implementation.

295 */

296 private class ListModel extends AbstractListModel

297 {

298 private List items;

384 * An action to cancel the popup.

385 */

386 private class CancelAction extends AbstractAction

387 {

388 /**

398 * An action selecting the current item.

399 */

400 private class SelectItemAction extends AbstractAction

401 {

402 /**

28 import java.util.*;

29

30 import org.gjt.sp.jedit.input.AbstractInputHandler;

31 import org.gjt.sp.jedit.input.InputHandlerProvider;

32 import org.gjt.sp.util.Log;

144 * @since jEdit 4.3pre13

145 */

146 public abstract class JEditActionSet<E extends JEditAbstractEditAction> implements InputHandlerProvider

147 {

148 //{{{ JEditActionSet constructor

399 * @since 4.3pre13

400 */

401 protected abstract JEditAbstractEditAction createBeanShellAction(String actionName,

402 String code,

403 String selected,

82 <p>

83 */

84 public abstract class BshClassManager

85 {

86 /** Singleton class manager */

269 /** @see #classForName( String ) */

270 public abstract Class getClassForName( String name );

271

272 /**

274 @see #plainClassForName( String )

275 */

276 public abstract Class getPlainClassForName( String name )

277 throws ClassNotFoundException ;

279 public abstract ClassLoader getBaseLoader();

280

281 public abstract ClassLoader getLoaderForClass( String name );

282

283 public abstract void addClassPath( URL path )

35 * XML handler for mode definition files.

36 */

37 public abstract class XModeHandler extends HandlerBase

38 {

39 //{{{ XModeHandler constructor

62 {

63 return new BufferedReader(new InputStreamReader(

64 getClass().getResourceAsStream(

65 "/org/gjt/sp/jedit/syntax/xmode.dtd")));

66 }

604 * @since jEdit 4.2pre1

605 */

606 protected abstract void error(String msg, Object subst);

607 //}}}

608

22 import javax.swing.plaf.ComponentUI;

23

24 public abstract class RevisionSelectionPanelUI extends ComponentUI {

25 }

26

54

55 LocalNameTest::LocalNameTest(const ItemType::Ptr &primaryType,

56 const QXmlName::LocalNameCode &ncName) : AbstractNodeTest(primaryType),

57 m_ncName(ncName)

58 {

83 ItemType::InstanceOf LocalNameTest::instanceOf() const

84 {

85 return ClassLocalNameTest;

86 }

87

88 bool LocalNameTest::operator==(const ItemType &other) const

89 {

90 return other.instanceOf() == ClassLocalNameTest &&

91 static_cast<const LocalNameTest &>(other).m_ncName == m_ncName;

92 }

49 <listitem>

50 <para><filename>Next_Char.bsh</filename></para>

51 <abstract><para>

52 Finds next occurence of character on current line.

53 </para></abstract>

29

30 import org.gjt.sp.util.Log;

31 import org.gjt.sp.jedit.AbstractOptionPane;

32 //}}}

33

38 * @version $Id: DummyOptionPane.java 6275 2004-08-21 22:33:34Z vanza $

39 */

40 public class DummyOptionPane extends AbstractOptionPane {

41

42 //{{{ +DummyOptionPane(String) : <init>

30 import java.util.Vector;

31 @SuppressWarnings("unchecked")

32 public abstract class AreaOp {

33 public static abstract class CAGOp extends AreaOp {

48 inRight = !inRight;

49 }

50 boolean newClass = newClassification(inLeft, inRight);

51 if (inResult == newClass) {

60 }

61

62 public abstract boolean newClassification(boolean inLeft,

63 boolean inRight);

64 }

148 public abstract void newRow();

149

150 public abstract int classify(Edge e);

151

152 public abstract int getState();

532 QDir (0x1eeaf40) 0

533

534 Class QAbstractFileEngine::ExtensionOption

535 size=1 align=1

536 base size=0 base align=1

537 QAbstractFileEngine::ExtensionOption (0x1fd8180) 0 empty

538

539 Class QAbstractFileEngine::ExtensionReturn

540 size=1 align=1

541 base size=0 base align=1

544 Vtable for QAbstractFileEngine

545 QAbstractFileEngine::_ZTV19QAbstractFileEngine: 36u entries

546 0 (int (*)(...))0

547 4 (int (*)(...))(& _ZTI19QAbstractFileEngine)

548 8 QAbstractFileEngine::~QAbstractFileEngine

549 12 QAbstractFileEngine::~QAbstractFileEngine

89

90 <KEYWORDS>

91 <KEYWORD1>abstract</KEYWORD1>

92 <KEYWORD1>as</KEYWORD1>

93 <KEYWORD1>base</KEYWORD1>

146 <KEYWORD3>byte</KEYWORD3>

147 <KEYWORD3>char</KEYWORD3>

148 <KEYWORD3>class</KEYWORD3>

149 <KEYWORD3>double</KEYWORD3>

150 <KEYWORD3>enum</KEYWORD3>

24

25 /**

26 * An adapter you can subclass to avoid having to implement all the methods

27 * of the {@link BufferListener} interface.

28 * @author Slava Pestov

30 * @since jEdit 4.3pre3

31 */

32 public abstract class BufferAdapter implements BufferListener

33 {

34 //{{{ foldLevelChanged() method

28 import java.util.ArrayList;

29 import javax.swing.*;

30 import org.gjt.sp.jedit.AbstractOptionPane;

31 import org.gjt.sp.jedit.EditAction;

32 import org.gjt.sp.jedit.PluginJAR;

43 * character map plugin.

44 */

45 public class CharacterMapOptionPane extends AbstractOptionPane

46 {

47 //{{{ Private Variables

30 //}}}

31

32 public class FirewallOptionPane extends AbstractOptionPane {

33

34 //{{{ FirewallOptionPane constructor

114 //}}}

115

116 //{{{ ActionHandler class

117 class ActionHandler implements ActionListener

1 /*

2 * StructureMatcher.java - Abstract interface for bracket matching, etc.

3 * :tabSize=8:indentSize=8:noTabs=false:

4 * :folding=explicit:collapseFolds=1:

57 //}}}

58

59 //{{{ BracketMatcher class

60 static class BracketMatcher implements StructureMatcher

94 } //}}}

95

96 //{{{ Match class

97 /**

98 * A structure match, denoted by a start and end position.

99 * @since jEdit 4.2pre3

100 */

101 public static class Match

102 {

103 public StructureMatcher matcher;

96 friend class Processes;

97 friend class processOopClass;

98 friend class vframeMirror;

225

226 vframeOop insertVFrameOop(vframeOop vfm);

227 vframeOop findVFrameOop(abstract_vframe* vfs);

228 vframeOop findInsertionPoint(abstract_vframe* vf);

231 void killVFrameOops(abstract_vframe* currentVF);

232 void killVFrameOopsInCurrentFrame(abstract_vframe* currentVF);

233 frame* frame_for_check_vfo_locals(abstract_vframe* currentVF);

242 void convertVFrameOops(frame* fr, frame* vfoLocals,

243 nmethod* invalidNM,

244 int32 vdepth, abstract_vframe** old_vf, abstract_vframe** new_vf);

245 void killVFrameOopsAndSetWatermark(frame* currentFrame);

246

291 <listitem>

292 <para><filename>Make_Get_and_Set_Methods.bsh</filename></para>

293 <abstract><para>

294 Creates <function>getXXX()</function> or <function>setXXX()</function>

295 methods that can be pasted into the buffer text.

296 </para></abstract>

297 <para>

298 This macro presents a dialog that will <quote>grab</quote> the names

34 </tr>

35 <tr>

36 <td class="blank"></td><td colspan="4">Add an AbstractToolPanel class. Should implement the EBComponent interface and provide the handleMessage method, as well as refresh and reload methods (example of use - refresh for reparsing a buffer, reload for reloading all data.)</td>

37 </tr>

38 <tr>

52 </tr>

53 <tr>

54 <td class="blank"></td><td colspan="4">Turn Bibtex and reference dialogs into panels subclassing AbstractToolPanel and add factory methods for generating the dialogs.</td>

55 </tr>

56 <tr>

76 </tr>

77 <tr>

78 <td class="blank"></td><td colspan="4">If the document is a tex file but is not the main file, then look for :latextools-main=*.tex: tag in the first or last 10 lines. Main file should be opened and be the file parsed for data. This should be implemented for all Tools - perhaps included in the AbstractToolPanel class.</td>

79 </tr>

80 <tr>

45 import org.gjt.sp.util.*;

46

47 public class ReferencePanel

48 extends AbstractToolPanel {

37 //{{{ DockingOptionPane class

38 public class DockingOptionPane extends AbstractOptionPane

39 {

40 //{{{ DockingOptionPane constructor

97 //{{{ DockPositionCellRenderer class

98 static class DockPositionCellRenderer extends JComboBox

99 implements TableCellRenderer

100 {

123 //{{{ WindowTableModel class

124 class WindowTableModel extends AbstractTableModel

125 {

126 private Vector windows;

162 //{{{ getColumnClass() method

163 public Class getColumnClass(int col)

164 {

165 switch(col)

26 import javax.swing.*;

27 import javax.swing.border.Border;

28 import javax.swing.border.AbstractBorder;

29 import javax.swing.border.CompoundBorder;

30 import javax.swing.event.MouseInputAdapter;

40 * @version $Id: HistoryTextArea.java 13415 2008-08-24 09:03:09Z k_satoda $

41 */

42 public class HistoryTextArea extends JTextArea

43 {

44 //{{{ HistoryTextArea constructor

20 * directory, creating a shortcut to start to program, and such.

21 */

22 public abstract class OperatingSystem

23 {

24 public abstract String getInstallDirectory(String name, String version);

25

26 public abstract static class OSTask

27 {

28 protected Install installer;

125 }

126

127 public class ScriptOSTask extends OSTask

128 {

129 public ScriptOSTask(Install installer)

21 import java.util.List;

22

23 import javax.swing.table.AbstractTableModel;

24

25

26 public class LabelTableModel

27 extends AbstractTableModel {

27 import java.awt.event.MouseEvent;

28

29 import javax.swing.AbstractAction;

30 import javax.swing.JLabel;

31 import javax.swing.JScrollPane;

46

47

48 public class BibTeXTablePanel

49 extends AbstractToolPanel {

109 String key = "Enter";

110 table.getActionMap().put(key,

111 new AbstractAction() {

112 public void actionPerformed(ActionEvent e) {

113 insert();

35 *

36 * The EditBus maintains a list of objects that have requested to receive

37 * messages. When a message is sent using this class, all registered

38 * components receive it in turn. Classes for objects that subscribe to

42 * A plugin core class that extends the

43 * {@link EBPlugin} abstract class (and whose name ends with

44 * <code>Plugin</code> for identification purposes) will automatically be

45 * added to the EditBus during jEdit's startup routine. Any other

46 * class - for example, a dockable window that needs to receive

47 * notification of buffer changes - must perform its own registration by calling

48 * {@link #addToBus(EBComponent)} during its initialization.

49 * A convenient place to register in a class derived from <code>JComponent</code>

50 * would be in an implementation of the <code>JComponent</code> method

51 * <code>addNotify()</code>.<p>

47 <listitem>

48 <para><filename>Look_and_Feel_Properties.bsh</filename></para>

49 <abstract><para>

50 Writes an unsorted list of the names of Java Look and Feel

51 properties in a new buffer.

52 </para></abstract>

53 </listitem>

54

34 * @since jEdit 3.2pre9

35 */

36 public class JCheckBoxList extends JTable

37 {

38 //{{{ JCheckBoxList constructor

238 }

239

240 class CheckBoxListModel extends AbstractTableModel

241 {

242 Vector items;

297 }

298

299 public Class getColumnClass(int col)

300 {

301 switch(col)

30 import javax.swing.JPanel;

31

32 import org.gjt.sp.jedit.AbstractOptionPane;

33 import org.gjt.sp.jedit.ActionSet;

34 import org.gjt.sp.jedit.EditAction;

41 // }}}

42

43 public class ToolBarOptionPane extends AbstractOptionPane

44 {

45

5 import java.util.*;

6

7 public class JavaCCParser implements JavaCCParserConstants {

8 Token t;

9 String lineSep = System.getProperty("line.separator");

952 while (true) {

953 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

954 case ABSTRACT:

955 case CLASS:

36 using namespace Phonon::MMF;

37

38 /*! \class MMF::AbstractVideoPlayer

39 \internal

40 */

44 //-----------------------------------------------------------------------------

45

46 MMF::AbstractVideoPlayer::AbstractVideoPlayer(MediaObject *parent, const AbstractPlayer *player)

47 : AbstractMediaPlayer(parent, player)

58 void MMF::AbstractVideoPlayer::construct()

59 {

60 TRACE_CONTEXT(AbstractVideoPlayer::AbstractVideoPlayer, EVideoApi);

61 TRACE_ENTRY_0();

62

73 }

74

75 MMF::AbstractVideoPlayer::~AbstractVideoPlayer()

76 {

77 TRACE_CONTEXT(AbstractVideoPlayer::~AbstractVideoPlayer, EVideoApi);

31 * @version $Id: GeneralOptions.java 963 2006-02-01 15:36:17Z daleanson $

32 **/

33 public class GeneralOptions

34 {

35 private boolean showStatusBar;

141 displayOpt.setVisSymbols(

142 props.getBooleanProperty("sidekick.java.custVisAsSymbol"));

143 displayOpt.setAbstractItalic(

144 props.getBooleanProperty("sidekick.java.custAbsAsItalic"));

145 displayOpt.setStaticUlined(

216 displayOpt.getVisSymbols());

217 props.setBooleanProperty("sidekick.java.custAbsAsItalic",

218 displayOpt.getAbstractItalic());

219 props.setBooleanProperty("sidekick.java.custStaAsUlined",

220 displayOpt.getStaticUlined());

49 boolean getShowArgumentNames();

50

51 // show qualified nested class or interface names

52 boolean getShowNestedName();

53

54 // not clear on this one -- appears to mean to show keywords like 'class' or

55 // 'interface' beside the icon

56 boolean getShowIconKeywords();

80 boolean getVisSymbols();

81

82 // if true, show abstract class names and methods in italics

83 boolean getAbstractItalic();

212 <ulink

213 url="jeditresource:/Sidekick.jar!/docs/api/sidekick/SideKickParser.html">

214 <classname>SideKickParser</classname></ulink> is an abstract class. The constructor takes one string parameter. This string is used in several properties:

215 </para>

216

284 <ulink url="jeditresource:/Sidekick.jar!/docs/api/sidekick/SideKickParsedData.html">SideKickParsedData </ulink>. Its constructor of the takes one parameter, which is the file name (to be shown at the root of the structure tree). Your method should

285 add structure elements to the <varname>root</varname> field of the instance.

286 <varname>root</varname> is an instance of Java's <classname>DefaultMutableTreeNode</classname> class,

287 and is given an initial value by the <classname>SideKickParsedData</classname> constructor.

472 <listitem><para>Added a new <classname>IAsset</classname> interface that can be

473 used instead of the <classname>Asset</classname> abstract class to realize more flexible

474 inheritance relationships.</para></listitem>

475 <listitem><para>Added a new option pane to associate edit modes with SideKick parsers.</para></listitem>

546 <listitem><para>Added <function>activate()</function> and

547 <function>deactivate()</function> methods to

548 <classname>SideKickParser</classname> class. These methods are called when

549 a buffer using this parser is selected and deselected in a given view.

550 </para></listitem>

32 * @author Mathieu Carbou (mathieu.carbou@gmail.com)

33 */

34 public abstract class MycilaJunit3Test extends TestCase {

35

36 private static final Logger LOGGER = Loggers.get(MycilaJunit3Test.class);

46 @Override

47 public final void runBare() throws Throwable {

48 final TestNotifier testNotifier = MycilaTesting.from(getClass()).configure(this).createNotifier(this);

49 ShutdownHook.get().add(new Closeable() {

50 public void close() throws Exception {

59 if (!testExecution.mustSkip()) {

60 try {

61 LOGGER.debug("Calling test method %s.%s", testExecution.method().getDeclaringClass().getName(), testExecution.method().getName());

62 super.runTest();

63 } catch (Throwable t) {

34 * Date: Apr 22, 2010

35 */

36 public abstract class PropertyProviderFinder extends AntDomRecursiveVisitor {

37

38 protected static <K, V> void cacheResult(@Nullable final DomElement context,

79

80 protected PropertyProviderFinder(DomElement contextElement) {

81 myContextElement = contextElement != null? contextElement.getParentOfType(AntDomElement.class, false) : null;

82 }

83

237 * @return true if search should be continued and false in order to stop

238 */

239 protected abstract void propertyProviderFound(PropertiesProvider propertiesProvider);

240

241

788 }

789

790 private static final class VarRefDetector extends AbstractXQueryParserVisitor {

791 private final BindingVariable _targetVar;

792 private final int _birthId;

850 }

851

852 private static final class PredicateReplacer extends AbstractXQueryParserVisitor {

853

854 private final XQExpression _target;

906 }

907

908 private static final class DependancyChecker extends AbstractXQueryParserVisitor {

909 private final List<Binding> _clauses;

910 private Binding _dependent = null;

46 * @author Dirk Moebius

47 */

48 public class SessionManagerDialog extends EnhancedDialog implements ActionListener, ListSelectionListener {

49

50 public SessionManagerDialog(View view, String currentSession) {

187 private void setNewListModel() {

188 final Vector listData = SessionManager.getSessionNames();

189 lSessions.setModel(new AbstractListModel() {

190 public int getSize() { return listData.size(); }

191 public Object getElementAt(int i) { return listData.elementAt(i); }

221 * A <tt>MouseListener</tt> for handling double-clicks on the sessions list.

222 */

223 private class MouseHandler extends MouseAdapter {

224

225 public void mousePressed(MouseEvent evt) {

32 //}}}

33

34 public class PluginOptions extends OptionsDialog

35 {

36 //{{{ PluginOptions constructor

76 continue;

77

78 String className = ep.getClassName();

79 if(jEdit.getProperty("plugin." + className + ".activate") == null)

94 {

95 String optionPane = jEdit.getProperty(

96 "plugin." + className + ".option-pane");

97 if(optionPane != null)

98 pluginsGroup.addOptionPane(optionPane);

137 //{{{ NoPluginsPane class

138 public static class NoPluginsPane extends AbstractOptionPane

139 {

140 public NoPluginsPane()

34 //}}}

35

36 public abstract class SystemShellBuiltIn

37 {

38 //{{{ SystemShellBuiltIn constructor

39 public SystemShellBuiltIn()

40 {

41 name = getClass().getName();

42 name = name.substring(name.lastIndexOf('$') + 1);

43

59 } //}}}

60

61 //{{{ Option class

62 public class Option

229

230 //{{{ execute() method

231 protected abstract void execute(Console console, Output output,

232 Output error, Vector args, Hashtable values); //}}}

233

59 /**

60 * @file

61 * @short Contains classes implementing the functions found in

62 * <a href="http://www.w3.org/TR/xpath-functions/#fns-that-generate-sequences">XQuery 1.0 and

63 * XPath 2.0 Functions and Operators, 15.5 Functions and Operators that Generate Sequences</a>.

78 * @author Frans Englich <frans.englich@nokia.com>

79 */

80 class IdFN : public ContextNodeChecker

81 {

82 public:

83 IdFN();

84 typedef QPair<DynamicContext::Ptr, const QAbstractXmlNodeModel *> IDContext;

85

86 virtual Item::Iterator::Ptr evaluateSequence(const DynamicContext::Ptr &context) const;

256 //{{{ PluginTableModel class

257 private class PluginTableModel extends AbstractTableModel

258 {

259 /** This List can contain String or Entry. */

264 //{{{ getColumnClass() method

265 @Override

266 public Class getColumnClass(int columnIndex)

267 {

268 switch (columnIndex)

668 * @TODO refactor to use the PluginDetailPanel?

669 */

670 private class PluginInfoBox extends JTextPane implements ListSelectionListener

671 {

672 private final String[] params;

859 //{{{ InstallButton class

860 private class InstallButton extends JButton implements ActionListener, TableModelListener

861 {

862 InstallButton()

53 * @version $Id: BufferIORequest.java 16339 2009-10-14 09:59:36Z kpouer $

54 */

55 public abstract class BufferIORequest extends WorkRequest

56 {

57 //{{{ Constants

121 public String toString()

122 {

123 return getClass().getName() + '[' + buffer + ']';

124 } //}}}

125

35 * @since jEdit 3.2pre9

36 */

37 public class JCheckBoxList extends JTable

38 {

39 //{{{ JCheckBoxList constructor

179 //}}}

180

181 //{{{ Entry class

182 /**

183 * A check box list entry.

254 //{{{ CheckBoxListModel class

255 class CheckBoxListModel extends AbstractTableModel

256 {

257 Vector<JCheckBoxList.Entry> items;

314

315 @Override

316 public Class getColumnClass(int col)

317 {

318 switch(col)

44 <listitem>

45 <para><filename>System_Properties.bsh</filename></para>

46 <abstract><para>

47 Writes an unsorted list of all Java system properties in a new

48 buffer.

49 </para></abstract>

50 </listitem>

51

469 */

470 private static Method findOverloadedMethod(

471 Class baseClass, String methodName, Class[] types, boolean publicOnly )

472 {

473 if ( Interpreter.DEBUG )

555 // Do we have a superclass? (interfaces don't, etc.)

556 Class superclass = baseClass.getSuperclass();

557 if ( superclass != null )

664 derived return type of otherwise identical best matches.

665

666 @see #findMostSpecificSignature(Class[], Class[][])

667 @param methods the set of candidate method which differ only in the

668 types of their arguments.

874 throws ReflectError if the Class is not an array class.

875 */

876 public static Class getArrayBaseType(Class arrayClass) throws ReflectError

877 {

878 if ( !arrayClass.isArray() )

225 TOKEN : /* RESERVED WORDS AND LITERALS */

226 {

227 < ABSTRACT : "abstract" >

228 | < BOOLEAN: "boolean" >

229 | < BREAK: "break" >

230 | < CLASS: "class" >

231 | < BYTE: "byte" >

232 | < CASE: "case" >

499 /**

500 */

501 void ClassDeclaration() #ClassDeclaration :

502 {

503 Modifiers mods;

38 <listitem>

39 <para><filename>Open_Path.bsh</filename></para>

40 <abstract><para>

41 Opens the file supplied by the user in an input dialog.

42 </para></abstract>

41 *

42 * It provides the interface between Freetype glyphs and their openGL

43 * renderable counterparts. This is an abstract class and derived classes

44 * must implement the <code>Render</code> function.

45 *

47 * @see FTPoint

48 */

49 class FTGL_EXPORT FTGlyph

50 {

51 protected:

69 friend class FTBitmapGlyph;

70 friend class FTBufferGlyph;

71 //friend class FTExtrudeGlyph;

126 *

127 * It provides the interface between Freetype glyphs and their openGL

128 * renderable counterparts. This is an abstract class and derived classes

129 * must implement the ftglRenderGlyph() function.

130 */

26

27 /**

28 * Manages a collection of action sets. There are two instances of this class

29 * in jEdit:

30 * <ul>

38 * @version $Id: ActionContext.java 13436 2008-08-27 02:32:08Z ezust $

39 */

40 public abstract class ActionContext extends JEditActionContext<EditAction, ActionSet>

41 {

42 //{{{ getActionSetForAction() method

39 import java.util.*;

40

41 public class AbstractTreeUpdater implements Disposable, Activatable {

42 private static final Logger LOG = Logger.getInstance("#com.intellij.ide.util.treeView.AbstractTreeUpdater");

43

44 private final LinkedList<TreeUpdatePass> myNodeQueue = new LinkedList<TreeUpdatePass>();

45 private final AbstractTreeBuilder myTreeBuilder;

46 private final List<Runnable> myRunAfterUpdate = new ArrayList<Runnable>();

47 private Runnable myRunBeforeUpdate;

51 private boolean myReleaseRequested;

52

53 public AbstractTreeUpdater(@NotNull AbstractTreeBuilder treeBuilder) {

54 myTreeBuilder = treeBuilder;

55 final JTree tree = myTreeBuilder.getTree();

108

109 /**

110 * @deprecated use {@link com.intellij.ide.util.treeView.AbstractTreeBuilder#queueUpdateFrom(Object, boolean)}

111 */

112 public synchronized void requeue(@NotNull TreeUpdatePass toAdd) {

32 * This is the option pane that jEdit displays for Plugin Options.

33 */

34 public class JCompilerPane

35 extends AbstractOptionPane

126 outputPanel);

127

128 // ========== Classpath options ==========

129 addSeparator("options.jcompiler.sep.classpath");

230

231 if (!useJavaCP.isSelected()) {

232 jEdit.setProperty("jcompiler.classpath", newCP.getText());

233 }

234

281 cpLabel.setText(jEdit.getProperty(

282 "options.jcompiler.usejavacp.true"));

283 newCP.setText(System.getProperty("java.class.path"));

284 newCP.setEnabled(false);

285 } else {

21 * Ethernet controllers. Written by Mitch Lichtenberg at Broadcom Corp.

22 *

23 * Updated to the driver model and the PHY abstraction layer

24 * by Maciej W. Rozycki.

25 */

131 obviously helpful is determining both the base plugin class and the

132 contents of a <filename>handleMessage()</filename> method. The message

133 classes derived from <classname>EBMessage</classname> cover the opening

134 and closing of the application, changes in the status of text buffers

135 and their container and changes in user settings, as well as changes in

176 <listitem>

177 <para>

178 <classname>ViewUpdate</classname>, sent when a <classname>View</classname>

179 is created or closed; and

180 </para>

205

206 <para>

207 Whether <classname>EditPlugin</classname> or <classname>EBPlugin</classname>

208 is selected as the base of the plugin core

209 class, the implementations of <function>start()</function> and

62 <KEYWORDS IGNORE_CASE="FALSE">

63 <!-- Some java keywords -->

64 <KEYWORD1>abstract</KEYWORD1>

65 <!-- <KEYWORD1>break</KEYWORD1> -->

66 <!-- <KEYWORD1>case</KEYWORD1> -->

99 <KEYWORD3>byte</KEYWORD3>

100 <KEYWORD3>char</KEYWORD3>

101 <KEYWORD3>class</KEYWORD3>

102 <KEYWORD3>double</KEYWORD3>

103 <KEYWORD3>float</KEYWORD3>

441 try

442 {

443 Class clazz = classLoader.loadClass(className,false);

444 int modifiers = clazz.getModifiers();

445 if(Modifier.isInterface(modifiers)

563 && buffer.getFoldHandler().getClass()

564 .getClassLoader() == classLoader)

565 {

566 buffer.setFoldHandler(

841 private File file;

842

843 private JARClassLoader classLoader;

844 private ZipFile zipFile;

845 private Properties properties;

869 private void loadCache(PluginCacheEntry cache)

870 {

871 classes = cache.classes;

872

873 /* this should be before dockables are initialized */

30 import javax.swing.border.TitledBorder;

31

32 import org.gjt.sp.jedit.AbstractOptionPane;

33 import org.gjt.sp.jedit.ServiceManager;

34 import org.gjt.sp.jedit.jEdit;

35

36 @SuppressWarnings("serial")

37 public class LCMOptions extends AbstractOptionPane

38 {

39 static public final String PROP_PREFIX = "options.LCMPlugin.";

53 {

54 String [] services = ServiceManager.getServiceNames(

55 DirtyLineProvider.class.getCanonicalName());

56 provider = new JComboBox(services);

57 String selected = getProviderServiceName();

26 * @author robmckinnon at users.sourceforge.net

27 */

28 public abstract class ParentMember extends Member {

29

30 ParentMember(String name) {

31 * @since jEdit 3.2pre1

32 */

33 public abstract class Selection

34 {

35 //{{{ getStart() method

76 * @param line The line number

77 */

78 public abstract int getStart(Buffer buffer, int line);

79 //}}}

80

86 * @param line The line number

87 */

88 public abstract int getEnd(Buffer buffer, int line);

89 //}}}

90

10

11 /// <summary>

12 ///This is a test class for AbstractEntryTest and is intended

13 ///to contain all AbstractEntryTest Unit Tests

14 ///</summary>

15 [TestFixture][Category("CoreClient")]

16 public class AbstractEntryTest

17 {

18

40 //You can use the following additional attributes as you write your tests:

41 //

42 //Use ClassInitialize to run code before running the first test in the class

43 //[ClassInitialize()]

46 //}

47 //

48 //Use ClassCleanup to run code after all tests in a class have run

49 //[ClassCleanup()]

31

32

33 public abstract class ArchiveCommand {

34 abstract Hashtable getDirectories(String archiveProtocol, String archivePath)

36

37

38 abstract InputStream createInputStream(String path) throws IOException;

39

40

5

6 /**

7 * This class provides an outline for distance functions on real valued spaces. Coordinates

8 * must be provided as {@code Vector}s containing {@code Double} values for each dimension.

9 *

11 * 27.02.2012

12 */

13 public abstract class Distance implements Serializable {

14

15

35 * @return

36 */

37 protected abstract Double computeDistance(Vector<Double> coordinates_a, Vector<Double> coordinates_b);

38 }

39

9 import stream.quantiles.impl.AbstractQuantileLearner;

10

11 public class SumQuantiles extends AbstractQuantileLearner {

12

13 private int slidingWindowSize = 5000;

106 }

107

108 private class Bucket implements Serializable {

109

110 /**

35 localName = "content"

36 )

37 public class MediaContent extends AbstractMediaResource {

38 private long fileSize;

39 private String type;

56 public static ExtensionDescription getDefaultDescription(boolean repeat) {

57 ExtensionDescription retval =

58 ExtensionDescription.getDefaultDescription(MediaContent.class);

59 retval.setRepeatable(repeat);

60 return retval;

192 isDefault = attrsHelper.consumeBoolean("isDefault", false);

193 expression =

194 attrsHelper.consumeEnum("expression", false, Expression.class);

195 bitrate = attrsHelper.consumeInteger("bitrate", false);

196 framerate = attrsHelper.consumeInteger("framerate", false);