text:
using System;
using System.Runtime.InteropServices;
using Llvm.NET.Native;

namespace Llvm.NET.DebugInfo
{
    /// see
    public class DIFile
        : DIScope
    {
        internal DIFile( LLVMMetadataRef handle )
            : base( handle )
        {
        }

        public string FileName
        {
            get
            {
                IntPtr name = NativeMethods.GetDIFileName( MetadataHandle );
                return Marshal.PtrToStringAnsi( name );
            }
        }

        public string Directory
        {
            get
            {
                IntPtr dir = NativeMethods.GetDIFileDirectory( MetadataHandle );
                return Marshal.PtrToStringAnsi( dir );
            }
        }

        public string Path => System.IO.Path.Combine( Directory, FileName );
    }
}


text:
  Argelès-sur-Mer est
      une ville située dans le département des Pyrénées-Orientales en Languedoc-Roussillon. Elle comptait 9 928 habitants en 2008.

À Argelès-sur-Mer le salaire moyen mensuel par habitant est situé à approximativement 1 893 €  net. C'est inférieur à la moyenne du pays.

La ville compte de nombreux  équipements sportifs, elle dispose, entre autres, de un bassin de natation, quatre terrains de tennis, six centres d'équitation et douze boucles de randonnée.

À proximité de Argelès-sur-Mer sont situées les villes de
Port-Vendres localisée à 7 km, 4 478 habitants,
Saint-André à 4 km, 2 712 habitants,
Collioure localisée à 5 km, 2 937 habitants,
Sorède à 5 km, 2 926 habitants,
Elne à 7 km, 7 325 habitants,
Saint-Cyprien à 8 km, 10 140 habitants,
 entre autres. De plus, Argelès-sur-Mer est située à seulement 20 km de Perpignan.

À Argelès-sur-Mer, le prix moyen à la vente d'un appartement s'évalue à 3 306 € du m² en vente. Le prix moyen d'une maison à l'achat se situe à 2 887 € du m². À la location le prix moyen se situe à 11,91 € du m² par mois.

Le parc de logements, à Argelès-sur-Mer, se décomposait en 2011 en 7 928 appartements et 5 810 maisons soit
une légère supériorité des appartements .

Argelès-sur-Mer apparait comme une commune où de nombreux marchants sont installés.
il existe à Argelès-sur-Mer deux hypermarchés, trois supermarchés et 19 supérettes.
Argelès-sur-Mer est une ville plutôt attractive pour un placement locatif.
lors d'une transaction immobilière la proximité des  commerces influence le prix de l'aquisition

La localité dispose s'agissant de l'enseignement aux enfants de un collège.
S'agissant les plus jeunes, la commune est pourvue pour le bien être de sa population de trois maternelles et deux écoles primaires.
Argelès-sur-Mer propose les équipements éducatifs permettant une vie locale facilitée.
Lors d'un projet d'acquisition immobilière à Argelès-sur-Mer, vous devrez impérativement regarder la qualité des équipements éducatifs

redpajama_set_name: RedPajamaGithub


text:
using System.Collections.Generic;
using Azure.Core;

namespace Azure.ResourceManager.Resources.Models
{
    /// <summary> List of deployment operations. </summary>
    public partial class DeploymentOperationsListResult
    {
        /// <summary> Initializes a new instance of DeploymentOperationsListResult. </summary>
        internal DeploymentOperationsListResult()
        {
            Value = new ChangeTrackingList<DeploymentOperation>();
        }

        /// <summary> Initializes a new instance of DeploymentOperationsListResult. </summary>
        /// <param name="value"> An array of deployment operations. </param>
        /// <param name="nextLink"> The URL to use for getting the next set of results. </param>
        internal DeploymentOperationsListResult(IReadOnlyList<DeploymentOperation> value, string nextLink)
        {
            Value = value;
            NextLink = nextLink;
        }

        /// <summary> An array of deployment operations. </summary>
        public IReadOnlyList<DeploymentOperation> Value { get; }
        /// <summary> The URL to use for getting the next set of results. </summary>
        public string NextLink { get; }
    }
}


text:
<?php

class BMSkillInsultTest extends PHPUnit_Framework_TestCase {
    /**
     * @var BMSkillInsult
     */
    protected $object;

    /**
     * Sets up the fixture, for example, opens a network connection.
     * This method is called before a test is executed.
     */
    protected function setUp()
    {
        $this->object = new BMSkillInsult;
    }

    /**
     * Tears down the fixture, for example, closes a network connection.
     * This method is called after a test is executed.
     */
    protected function tearDown()
    {
    }

    /**
     * this dummy test is here to satisfy PHPUnit
     */
    public function testDummy()
    {

    }
}


text:
using System;
using System.Text;
using System.Runtime.InteropServices;

namespace Steam4NET
{

	[StructLayout(LayoutKind.Sequential,Pack=4)]
	public class ISteamRemoteStorage010VTable
	{
		public IntPtr FileWrite0;
		public IntPtr FileRead1;
		public IntPtr FileForget2;
		public IntPtr FileDelete3;
		public IntPtr FileShare4;
		public IntPtr SetSyncPlatforms5;
		public IntPtr FileWriteStreamOpen6;
		public IntPtr FileWriteStreamWriteChunk7;
		public IntPtr FileWriteStreamClose8;
		public IntPtr FileWriteStreamCancel9;
		public IntPtr FileExists10;
		public IntPtr FilePersisted11;
		public IntPtr GetFileSize12;
		public IntPtr GetFileTimestamp13;
		public IntPtr GetSyncPlatforms14;
		public IntPtr GetFileCount15;
		public IntPtr GetFileNameAndSize16;
		public IntPtr GetQuota17;
		public IntPtr IsCloudEnabledForAccount18;
		public IntPtr IsCloudEnabledForApp19;
		public IntPtr SetCloudEnabledForApp20;
		public IntPtr UGCDownload21;
		public IntPtr GetUGCDownloadProgress22;
		public IntPtr GetUGCDetails23;
		public IntPtr UGCRead24;
		public IntPtr GetCachedUGCCount25;
		public IntPtr GetCachedUGCHandle26;
		public IntPtr PublishWorkshopFile27;
		public IntPtr CreatePublishedFileUpdateRequest28;
		public IntPtr UpdatePublishedFileFile29;
		public IntPtr UpdatePublishedFilePreviewFile30;
		public IntPtr UpdatePublishedFileTitle31;
		public IntPtr UpdatePublishedFileDescription32;
		public IntPtr UpdatePublishedFileVisibility33;
		public IntPtr UpdatePublishedFileTags34;
		public IntPtr CommitPublishedFileUpdate35;
		public IntPtr GetPublishedFileDetails36;
		public IntPtr DeletePublishedFile37;
		public IntPtr EnumerateUserPublishedFiles38;
		public IntPtr SubscribePublishedFile39;
		public IntPtr EnumerateUserSubscribedFiles40;
		public IntPtr UnsubscribePublishedFile41;
		public IntPtr UpdatePublishedFileSetChangeDescription42;
		public IntPtr GetPublishedItemVoteDetails43;
		public IntPtr UpdateUserPublishedItemVote44;
		public IntPtr GetUserPublishedItemVoteDetails45;
		public IntPtr EnumerateUserSharedWorkshopFiles46;
		public IntPtr PublishVideo47;
		public IntPtr SetUserPublishedFileAction48;
		public IntPtr EnumeratePublishedFilesByUserAction49;
		public IntPtr EnumeratePublishedWorkshopFiles50;
		public IntPtr UGCDownloadToLocation51;
		private IntPtr DTorISteamRemoteStorage01052;
	};

	[InteropHelp.InterfaceVersion("STEAMREMOTESTORAGE_INTERFACE_VERSION010")]
	public class ISteamRemoteStorage010 : InteropHelp.NativeWrapper<ISteamRemoteStorage010VTable>
	{
		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFileWriteSBI( IntPtr thisptr, string pchFile, Byte[] pvData, Int32 cubData );
		public bool FileWrite( string pchFile, Byte[] pvData )
		{
			return this.GetFunction<NativeFileWriteSBI>( this.Functions.FileWrite0 )( this.ObjectAddress, pchFile, pvData, (Int32) pvData.Length );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeFileReadSBI( IntPtr thisptr, string pchFile, Byte[] pvData, Int32 cubDataToRead );
		public Int32 FileRead( string pchFile, Byte[] pvData )
		{
			return this.GetFunction<NativeFileReadSBI>( this.Functions.FileRead1 )( this.ObjectAddress, pchFile, pvData, (Int32) pvData.Length );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFileForgetS( IntPtr thisptr, string pchFile );
		public bool FileForget( string pchFile )
		{
			return this.GetFunction<NativeFileForgetS>( this.Functions.FileForget2 )( this.ObjectAddress, pchFile );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFileDeleteS( IntPtr thisptr, string pchFile );
		public bool FileDelete( string pchFile )
		{
			return this.GetFunction<NativeFileDeleteS>( this.Functions.FileDelete3 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeFileShareS( IntPtr thisptr, string pchFile );
		public UInt64 FileShare( string pchFile )
		{
			return this.GetFunction<NativeFileShareS>( this.Functions.FileShare4 )( this.ObjectAddress, pchFile );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeSetSyncPlatformsSE( IntPtr thisptr, string pchFile, ERemoteStoragePlatform eRemoteStoragePlatform );
		public bool SetSyncPlatforms( string pchFile, ERemoteStoragePlatform eRemoteStoragePlatform )
		{
			return this.GetFunction<NativeSetSyncPlatformsSE>( this.Functions.SetSyncPlatforms5 )( this.ObjectAddress, pchFile, eRemoteStoragePlatform );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeFileWriteStreamOpenS( IntPtr thisptr, string pchFile );
		public UInt64 FileWriteStreamOpen( string pchFile )
		{
			return this.GetFunction<NativeFileWriteStreamOpenS>( this.Functions.FileWriteStreamOpen6 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamWriteChunkUBI( IntPtr thisptr, UInt64 hStream, Byte[] pvData, Int32 cubData );
		public EResult FileWriteStreamWriteChunk( UInt64 hStream, Byte[] pvData )
		{
			return this.GetFunction<NativeFileWriteStreamWriteChunkUBI>( this.Functions.FileWriteStreamWriteChunk7 )( this.ObjectAddress, hStream, pvData, (Int32) pvData.Length );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamCloseU( IntPtr thisptr, UInt64 hStream );
		public EResult FileWriteStreamClose( UInt64 hStream )
		{
			return this.GetFunction<NativeFileWriteStreamCloseU>( this.Functions.FileWriteStreamClose8 )( this.ObjectAddress, hStream );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamCancelU( IntPtr thisptr, UInt64 hStream );
		public EResult FileWriteStreamCancel( UInt64 hStream )
		{
			return this.GetFunction<NativeFileWriteStreamCancelU>( this.Functions.FileWriteStreamCancel9 )( this.ObjectAddress, hStream );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFileExistsS( IntPtr thisptr, string pchFile );
		public bool FileExists( string pchFile )
		{
			return this.GetFunction<NativeFileExistsS>( this.Functions.FileExists10 )( this.ObjectAddress, pchFile );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFilePersistedS( IntPtr thisptr, string pchFile );
		public bool FilePersisted( string pchFile )
		{
			return this.GetFunction<NativeFilePersistedS>( this.Functions.FilePersisted11 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeGetFileSizeS( IntPtr thisptr, string pchFile );
		public Int32 GetFileSize( string pchFile )
		{
			return this.GetFunction<NativeGetFileSizeS>( this.Functions.GetFileSize12 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int64 NativeGetFileTimestampS( IntPtr thisptr, string pchFile );
		public Int64 GetFileTimestamp( string pchFile )
		{
			return this.GetFunction<NativeGetFileTimestampS>( this.Functions.GetFileTimestamp13 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate ERemoteStoragePlatform NativeGetSyncPlatformsS( IntPtr thisptr, string pchFile );
		public ERemoteStoragePlatform GetSyncPlatforms( string pchFile )
		{
			return this.GetFunction<NativeGetSyncPlatformsS>( this.Functions.GetSyncPlatforms14 )( this.ObjectAddress, pchFile );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeGetFileCount( IntPtr thisptr );
		public Int32 GetFileCount(  )
		{
			return this.GetFunction<NativeGetFileCount>( this.Functions.GetFileCount15 )( this.ObjectAddress );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetFileNameAndSizeII( IntPtr thisptr, Int32 iFile, ref Int32 pnFileSizeInBytes );
		public string GetFileNameAndSize( Int32 iFile, ref Int32 pnFileSizeInBytes )
		{
			return InteropHelp.DecodeANSIReturn( Marshal.PtrToStringAnsi( this.GetFunction<NativeGetFileNameAndSizeII>( this.Functions.GetFileNameAndSize16 )( this.ObjectAddress, iFile, ref pnFileSizeInBytes ) ) );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetQuotaII( IntPtr thisptr, ref Int32 pnTotalBytes, ref Int32 puAvailableBytes );
		public bool GetQuota( ref Int32 pnTotalBytes, ref Int32 puAvailableBytes )
		{
			return this.GetFunction<NativeGetQuotaII>( this.Functions.GetQuota17 )( this.ObjectAddress, ref pnTotalBytes, ref puAvailableBytes );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsCloudEnabledForAccount( IntPtr thisptr );
		public bool IsCloudEnabledForAccount(  )
		{
			return this.GetFunction<NativeIsCloudEnabledForAccount>( this.Functions.IsCloudEnabledForAccount18 )( this.ObjectAddress );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsCloudEnabledForApp( IntPtr thisptr );
		public bool IsCloudEnabledForApp(  )
		{
			return this.GetFunction<NativeIsCloudEnabledForApp>( this.Functions.IsCloudEnabledForApp19 )( this.ObjectAddress );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetCloudEnabledForAppB( IntPtr thisptr, [MarshalAs(UnmanagedType.I1)] bool bEnabled );
		public void SetCloudEnabledForApp( bool bEnabled )
		{
			this.GetFunction<NativeSetCloudEnabledForAppB>( this.Functions.SetCloudEnabledForApp20 )( this.ObjectAddress, bEnabled );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUGCDownloadUU( IntPtr thisptr, UInt64 hContent, UInt32 uUnk );
		public UInt64 UGCDownload( UInt64 hContent, UInt32 uUnk )
		{
			return this.GetFunction<NativeUGCDownloadUU>( this.Functions.UGCDownload21 )( this.ObjectAddress, hContent, uUnk );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetUGCDownloadProgressUUU( IntPtr thisptr, UInt64 hContent, ref UInt32 puDownloadedBytes, ref UInt32 puTotalBytes );
		public bool GetUGCDownloadProgress( UInt64 hContent, ref UInt32 puDownloadedBytes, ref UInt32 puTotalBytes )
		{
			return this.GetFunction<NativeGetUGCDownloadProgressUUU>( this.Functions.GetUGCDownloadProgress22 )( this.ObjectAddress, hContent, ref puDownloadedBytes, ref puTotalBytes );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetUGCDetailsUUSIC( IntPtr thisptr, UInt64 hContent, ref UInt32 pnAppID, StringBuilder ppchName, ref Int32 pnFileSizeInBytes, ref UInt64 pSteamIDOwner );
		public bool GetUGCDetails( UInt64 hContent, ref UInt32 pnAppID, StringBuilder ppchName, ref Int32 pnFileSizeInBytes, ref CSteamID pSteamIDOwner )
		{
			UInt64 s0 = 0; var result = this.GetFunction<NativeGetUGCDetailsUUSIC>( this.Functions.GetUGCDetails23 )( this.ObjectAddress, hContent, ref pnAppID, ppchName, ref pnFileSizeInBytes, ref s0 ); pSteamIDOwner = new CSteamID(s0); return result;
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeUGCReadUBIU( IntPtr thisptr, UInt64 hContent, Byte[] pvData, Int32 cubDataToRead, UInt32 uOffset );
		public Int32 UGCRead( UInt64 hContent, Byte[] pvData, UInt32 uOffset )
		{
			return this.GetFunction<NativeUGCReadUBIU>( this.Functions.UGCRead24 )( this.ObjectAddress, hContent, pvData, (Int32) pvData.Length, uOffset );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeGetCachedUGCCount( IntPtr thisptr );
		public Int32 GetCachedUGCCount(  )
		{
			return this.GetFunction<NativeGetCachedUGCCount>( this.Functions.GetCachedUGCCount25 )( this.ObjectAddress );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetCachedUGCHandleI( IntPtr thisptr, Int32 iCachedContent );
		public UInt64 GetCachedUGCHandle( Int32 iCachedContent )
		{
			return this.GetFunction<NativeGetCachedUGCHandleI>( this.Functions.GetCachedUGCHandle26 )( this.ObjectAddress, iCachedContent );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishWorkshopFileSSUSSESE( IntPtr thisptr, string pchFile, string pchPreviewFile, UInt32 nConsumerAppId, string pchTitle, string pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags, EWorkshopFileType eWorkshopFileType );
		public UInt64 PublishWorkshopFile( string pchFile, string pchPreviewFile, UInt32 nConsumerAppId, string pchTitle, string pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags, EWorkshopFileType eWorkshopFileType )
		{
			return this.GetFunction<NativePublishWorkshopFileSSUSSESE>( this.Functions.PublishWorkshopFile27 )( this.ObjectAddress, pchFile, pchPreviewFile, nConsumerAppId, pchTitle, pchDescription, eVisibility, ref pTags, eWorkshopFileType );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeCreatePublishedFileUpdateRequestU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 CreatePublishedFileUpdateRequest( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeCreatePublishedFileUpdateRequestU>( this.Functions.CreatePublishedFileUpdateRequest28 )( this.ObjectAddress, unPublishedFileId );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileFileUS( IntPtr thisptr, UInt64 hUpdateRequest, string pchFile );
		public bool UpdatePublishedFileFile( UInt64 hUpdateRequest, string pchFile )
		{
			return this.GetFunction<NativeUpdatePublishedFileFileUS>( this.Functions.UpdatePublishedFileFile29 )( this.ObjectAddress, hUpdateRequest, pchFile );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFilePreviewFileUS( IntPtr thisptr, UInt64 hUpdateRequest, string pchPreviewFile );
		public bool UpdatePublishedFilePreviewFile( UInt64 hUpdateRequest, string pchPreviewFile )
		{
			return this.GetFunction<NativeUpdatePublishedFilePreviewFileUS>( this.Functions.UpdatePublishedFilePreviewFile30 )( this.ObjectAddress, hUpdateRequest, pchPreviewFile );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileTitleUS( IntPtr thisptr, UInt64 hUpdateRequest, string pchTitle );
		public bool UpdatePublishedFileTitle( UInt64 hUpdateRequest, string pchTitle )
		{
			return this.GetFunction<NativeUpdatePublishedFileTitleUS>( this.Functions.UpdatePublishedFileTitle31 )( this.ObjectAddress, hUpdateRequest, pchTitle );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileDescriptionUS( IntPtr thisptr, UInt64 hUpdateRequest, string pchDescription );
		public bool UpdatePublishedFileDescription( UInt64 hUpdateRequest, string pchDescription )
		{
			return this.GetFunction<NativeUpdatePublishedFileDescriptionUS>( this.Functions.UpdatePublishedFileDescription32 )( this.ObjectAddress, hUpdateRequest, pchDescription );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileVisibilityUE( IntPtr thisptr, UInt64 hUpdateRequest, ERemoteStoragePublishedFileVisibility eVisibility );
		public bool UpdatePublishedFileVisibility( UInt64 hUpdateRequest, ERemoteStoragePublishedFileVisibility eVisibility )
		{
			return this.GetFunction<NativeUpdatePublishedFileVisibilityUE>( this.Functions.UpdatePublishedFileVisibility33 )( this.ObjectAddress, hUpdateRequest, eVisibility );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileTagsUS( IntPtr thisptr, UInt64 hUpdateRequest, ref SteamParamStringArray_t pTags );
		public bool UpdatePublishedFileTags( UInt64 hUpdateRequest, ref SteamParamStringArray_t pTags )
		{
			return this.GetFunction<NativeUpdatePublishedFileTagsUS>( this.Functions.UpdatePublishedFileTags34 )( this.ObjectAddress, hUpdateRequest, ref pTags );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeCommitPublishedFileUpdateU( IntPtr thisptr, UInt64 hUpdateRequest );
		public UInt64 CommitPublishedFileUpdate( UInt64 hUpdateRequest )
		{
			return this.GetFunction<NativeCommitPublishedFileUpdateU>( this.Functions.CommitPublishedFileUpdate35 )( this.ObjectAddress, hUpdateRequest );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetPublishedFileDetailsU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 GetPublishedFileDetails( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeGetPublishedFileDetailsU>( this.Functions.GetPublishedFileDetails36 )( this.ObjectAddress, unPublishedFileId );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeDeletePublishedFileU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 DeletePublishedFile( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeDeletePublishedFileU>( this.Functions.DeletePublishedFile37 )( this.ObjectAddress, unPublishedFileId );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserPublishedFilesU( IntPtr thisptr, UInt32 uStartIndex );
		public UInt64 EnumerateUserPublishedFiles( UInt32 uStartIndex )
		{
			return this.GetFunction<NativeEnumerateUserPublishedFilesU>( this.Functions.EnumerateUserPublishedFiles38 )( this.ObjectAddress, uStartIndex );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeSubscribePublishedFileU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 SubscribePublishedFile( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeSubscribePublishedFileU>( this.Functions.SubscribePublishedFile39 )( this.ObjectAddress, unPublishedFileId );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserSubscribedFilesU( IntPtr thisptr, UInt32 uStartIndex );
		public UInt64 EnumerateUserSubscribedFiles( UInt32 uStartIndex )
		{
			return this.GetFunction<NativeEnumerateUserSubscribedFilesU>( this.Functions.EnumerateUserSubscribedFiles40 )( this.ObjectAddress, uStartIndex );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUnsubscribePublishedFileU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 UnsubscribePublishedFile( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeUnsubscribePublishedFileU>( this.Functions.UnsubscribePublishedFile41 )( this.ObjectAddress, unPublishedFileId );
		}

		[return: MarshalAs(UnmanagedType.I1)]
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileSetChangeDescriptionUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszDescription );
		public bool UpdatePublishedFileSetChangeDescription( UInt64 hUpdateRequest, string cszDescription )
		{
			return this.GetFunction<NativeUpdatePublishedFileSetChangeDescriptionUS>( this.Functions.UpdatePublishedFileSetChangeDescription42 )( this.ObjectAddress, hUpdateRequest, cszDescription );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetPublishedItemVoteDetailsU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 GetPublishedItemVoteDetails( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeGetPublishedItemVoteDetailsU>( this.Functions.GetPublishedItemVoteDetails43 )( this.ObjectAddress, unPublishedFileId );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUpdateUserPublishedItemVoteUB( IntPtr thisptr, UInt64 unPublishedFileId, [MarshalAs(UnmanagedType.I1)] bool bVoteUp );
		public UInt64 UpdateUserPublishedItemVote( UInt64 unPublishedFileId, bool bVoteUp )
		{
			return this.GetFunction<NativeUpdateUserPublishedItemVoteUB>( this.Functions.UpdateUserPublishedItemVote44 )( this.ObjectAddress, unPublishedFileId, bVoteUp );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetUserPublishedItemVoteDetailsU( IntPtr thisptr, UInt64 unPublishedFileId );
		public UInt64 GetUserPublishedItemVoteDetails( UInt64 unPublishedFileId )
		{
			return this.GetFunction<NativeGetUserPublishedItemVoteDetailsU>( this.Functions.GetUserPublishedItemVoteDetails45 )( this.ObjectAddress, unPublishedFileId );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserSharedWorkshopFilesUCUSS( IntPtr thisptr, UInt32 nAppId, UInt64 creatorSteamID, UInt32 uStartIndex, ref SteamParamStringArray_t pRequiredTags, ref SteamParamStringArray_t pExcludedTags );
		public UInt64 EnumerateUserSharedWorkshopFiles( UInt32 nAppId, CSteamID creatorSteamID, UInt32 uStartIndex, ref SteamParamStringArray_t pRequiredTags, ref SteamParamStringArray_t pExcludedTags )
		{
			return this.GetFunction<NativeEnumerateUserSharedWorkshopFilesUCUSS>( this.Functions.EnumerateUserSharedWorkshopFiles46 )( this.ObjectAddress, nAppId, creatorSteamID.ConvertToUint64(), uStartIndex, ref pRequiredTags, ref pExcludedTags );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishVideoESSSUSSES( IntPtr thisptr, EWorkshopVideoProvider eVideoProvider, string cszVideoAccountName, string cszVideoIdentifier, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags );
		public UInt64 PublishVideo( EWorkshopVideoProvider eVideoProvider, string cszVideoAccountName, string cszVideoIdentifier, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags )
		{
			return this.GetFunction<NativePublishVideoESSSUSSES>( this.Functions.PublishVideo47 )( this.ObjectAddress, eVideoProvider, cszVideoAccountName, cszVideoIdentifier, cszFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, ref pTags );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeSetUserPublishedFileActionUE( IntPtr thisptr, UInt64 unPublishedFileId, EWorkshopFileAction eAction );
		public UInt64 SetUserPublishedFileAction( UInt64 unPublishedFileId, EWorkshopFileAction eAction )
		{
			return this.GetFunction<NativeSetUserPublishedFileActionUE>( this.Functions.SetUserPublishedFileAction48 )( this.ObjectAddress, unPublishedFileId, eAction );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumeratePublishedFilesByUserActionEU( IntPtr thisptr, EWorkshopFileAction eAction, UInt32 uStartIndex );
		public UInt64 EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, UInt32 uStartIndex )
		{
			return this.GetFunction<NativeEnumeratePublishedFilesByUserActionEU>( this.Functions.EnumeratePublishedFilesByUserAction49 )( this.ObjectAddress, eAction, uStartIndex );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumeratePublishedWorkshopFilesEUUUSS( IntPtr thisptr, EWorkshopEnumerationType eType, UInt32 uStartIndex, UInt32 cDays, UInt32 cCount, ref SteamParamStringArray_t pTags, ref SteamParamStringArray_t pUserTags );
		public UInt64 EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eType, UInt32 uStartIndex, UInt32 cDays, UInt32 cCount, ref SteamParamStringArray_t pTags, ref SteamParamStringArray_t pUserTags )
		{
			return this.GetFunction<NativeEnumeratePublishedWorkshopFilesEUUUSS>( this.Functions.EnumeratePublishedWorkshopFiles50 )( this.ObjectAddress, eType, uStartIndex, cDays, cCount, ref pTags, ref pUserTags );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUGCDownloadToLocationUSU( IntPtr thisptr, UInt64 hContent, string cszLocation, UInt32 uUnk );
		public UInt64 UGCDownloadToLocation( UInt64 hContent, string cszLocation, UInt32 uUnk )
		{
			return this.GetFunction<NativeUGCDownloadToLocationUSU>( this.Functions.UGCDownloadToLocation51 )( this.ObjectAddress, hContent, cszLocation, uUnk );
		}

	};
}


text:
package fiddle.ruby.json.serializer;

import java.io.IOException;
import java.util.Map.Entry;
import java.util.Set;

import org.jruby.RubyHash;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

public class RubyHashSerializer extends JsonSerializer<RubyHash> {

	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public void serialize(RubyHash rh, JsonGenerator gen,
			SerializerProvider prov) throws IOException,
			JsonProcessingException {

		gen.writeStartObject();

		final Set<Entry> set = rh.directEntrySet();

		for (final Entry entry : set) {
			gen.writeFieldName(entry.getKey().toString());
			prov.defaultSerializeValue(entry.getValue(), gen);
		}

		gen.writeEndObject();
	}

}


text:
<?xml version="1.0" encoding="UTF-8" ?>
<class name="EditorSceneImporter" inherits="Reference" category="Core" version="3.2">
	<brief_description>
	</brief_description>
	<description>
	</description>
	<tutorials>
	</tutorials>
	<methods>
		<method name="_get_extensions" qualifiers="virtual">
			<return type="Array">
			</return>
			<description>
			</description>
		</method>
		<method name="_get_import_flags" qualifiers="virtual">
			<return type="int">
			</return>
			<description>
			</description>
		</method>
		<method name="_import_animation" qualifiers="virtual">
			<return type="Animation">
			</return>
			<argument index="0" name="path" type="String">
			</argument>
			<argument index="1" name="flags" type="int">
			</argument>
			<argument index="2" name="bake_fps" type="int">
			</argument>
			<description>
			</description>
		</method>
		<method name="_import_scene" qualifiers="virtual">
			<return type="Node">
			</return>
			<argument index="0" name="path" type="String">
			</argument>
			<argument index="1" name="flags" type="int">
			</argument>
			<argument index="2" name="bake_fps" type="int">
			</argument>
			<description>
			</description>
		</method>
		<method name="import_animation_from_other_importer">
			<return type="Animation">
			</return>
			<argument index="0" name="path" type="String">
			</argument>
			<argument index="1" name="flags" type="int">
			</argument>
			<argument index="2" name="bake_fps" type="int">
			</argument>
			<description>
			</description>
		</method>
		<method name="import_scene_from_other_importer">
			<return type="Node">
			</return>
			<argument index="0" name="path" type="String">
			</argument>
			<argument index="1" name="flags" type="int">
			</argument>
			<argument index="2" name="bake_fps" type="int">
			</argument>
			<description>
			</description>
		</method>
	</methods>
	<constants>
		<constant name="IMPORT_SCENE" value="1">
		</constant>
		<constant name="IMPORT_ANIMATION" value="2">
		</constant>
		<constant name="IMPORT_ANIMATION_DETECT_LOOP" value="4">
		</constant>
		<constant name="IMPORT_ANIMATION_OPTIMIZE" value="8">
		</constant>
		<constant name="IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS" value="16">
		</constant>
		<constant name="IMPORT_ANIMATION_KEEP_VALUE_TRACKS" value="32">
		</constant>
		<constant name="IMPORT_GENERATE_TANGENT_ARRAYS" value="256">
		</constant>
		<constant name="IMPORT_FAIL_ON_MISSING_DEPENDENCIES" value="512">
		</constant>
		<constant name="IMPORT_MATERIALS_IN_INSTANCES" value="1024">
		</constant>
		<constant name="IMPORT_USE_COMPRESSION" value="2048">
		</constant>
	</constants>
</class>


text:
print "Hello World!"
print "Hello Again."


text:
package org.springframework.context.annotation.configuration;

import org.junit.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationCondition;
import org.springframework.context.annotation.Import;
import org.springframework.core.type.AnnotatedTypeMetadata;

import static org.junit.Assert.*;

/**
 * @author Andy Wilkinson
 */
public class ImportWithConditionTests {

	private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

	@Test
	public void conditionalThenUnconditional() throws Exception {
		this.context.register(ConditionalThenUnconditional.class);
		this.context.refresh();
		assertFalse(this.context.containsBean("beanTwo"));
		assertTrue(this.context.containsBean("beanOne"));
	}

	@Test
	public void unconditionalThenConditional() throws Exception {
		this.context.register(UnconditionalThenConditional.class);
		this.context.refresh();
		assertFalse(this.context.containsBean("beanTwo"));
		assertTrue(this.context.containsBean("beanOne"));
	}

	@Configuration
	@Import({ConditionalConfiguration.class, UnconditionalConfiguration.class})
	protected static class ConditionalThenUnconditional {

		@Autowired
		private BeanOne beanOne;
	}

	@Configuration
	@Import({UnconditionalConfiguration.class, ConditionalConfiguration.class})
	protected static class UnconditionalThenConditional {

		@Autowired
		private BeanOne beanOne;
	}

	@Configuration
	@Import(BeanProvidingConfiguration.class)
	protected static class UnconditionalConfiguration {
	}

	@Configuration
	@Conditional(NeverMatchingCondition.class)
	@Import(BeanProvidingConfiguration.class)
	protected static class ConditionalConfiguration {
	}

	@Configuration
	protected static class BeanProvidingConfiguration {

		@Bean
		BeanOne beanOne() {
			return new BeanOne();
		}
	}

	private static final class BeanOne {
	}

	private static final class NeverMatchingCondition implements ConfigurationCondition {

		@Override
		public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
			return false;
		}

		@Override
		public ConfigurationPhase getConfigurationPhase() {
			return ConfigurationPhase.REGISTER_BEAN;
		}
	}

}


text:
<?php

namespace BenTools\ETL\Exception;

use Throwable;

final class UnexpectedTypeException extends \InvalidArgumentException
{
    /**
     * @inheritDoc
     */
    public function __construct(string $expectedType, $actualObject, Throwable $previous = null)
    {
        if (is_a($expectedType, $expectedType, true)) {
            $message = sprintf('Expected instance of %s, %s given.', $expectedType, \is_object($actualObject) ? \get_class($actualObject) : \gettype($actualObject));
        } else {
            $message = sprintf('Expected %s, %s given.', $expectedType, \is_object($actualObject) ? \get_class($actualObject) : \gettype($actualObject));
        }
        parent::__construct($message, 0, $previous);
    }

    /**
     * Throw an UnexpectedTypeException if actual object doesn't match expected type.
     *
     * @param        $actualObject
     * @param string $expectedType
     * @param bool   $allowNull
     * @throws UnexpectedTypeException
     */
    public static function throwIfNot($actualObject, string $expectedType, bool $allowNull = false): void
    {
        if (!is_a($expectedType, $expectedType, true)) {
            if (\gettype($actualObject) !== $expectedType) {
                if (null === $actualObject && $allowNull) {
                    return;
                }
                throw new self($expectedType, $actualObject);
            }
            return;
        }

        if (!$actualObject instanceof $expectedType) {
            if (null === $actualObject && $allowNull) {
                return;
            }
            throw new self($expectedType, $actualObject);
        }
    }
}


text:
"""This module is deprecated. Please use :mod:`airflow.providers.amazon.aws.sensors.s3_key`."""

import warnings

# pylint: disable=unused-import
from airflow.providers.amazon.aws.sensors.s3_key import S3KeySensor  # noqa

warnings.warn(
    "This module is deprecated. Please use `airflow.providers.amazon.aws.sensors.s3_key`.",
    DeprecationWarning,
    stacklevel=2,
)


text:
fiddle-20150412-GridItemContextFilterPlugin
======

![Screenshot](screenshot.png)

### Title

Grid Item Context Filter Plugin

### Creation Date

04-12-15

### Description

Fiddle exploring how to create a grid filtering plug-in that provides type-ahead suggestions.

### Published Version Link

[sencha fiddle](https://fiddle.sencha.com/#fiddle/l65)

### Tags

ExtJS-5-1, data, store, combo, picker, chainedstore, grid, filter, MVVM, plugin, itemcontextmenu

### Forked From

[fiddle-20150407-ChainedStoreFiltering](../fiddle-20150407-ChainedStoreFiltering/README.markdown)

### Forked From

[fiddle-20150408-GridDynamicFieldFilter](../fiddle-20150408-GridDynamicFieldFilter/README.markdown)


text:
h1(class='s-simple-title  u-fs-h5x') Split Object
h2.s-simple-title--sub Definition List
.s-simple-objects.split
  dl.o-split
    dt.o-split__title Burger and fries
    dd £5.99
    dt.o-split__title Fillet steak
    dd £19.99
    dt.o-split__title Ice cream
    dd £2.99
.s-simple-code
  p this will be code
h2.s-simple-title--sub Order List
.s-simple-objects.split
  ol.o-split
    li.first
      b.o-split__title 1st place
      | Bob
    li.second
      b.o-split__title 2nd place
      | Lilly
    li.third
      b.o-split__title 3rd place
      | Ted
.s-simple-code
  include ../code/highlight/highlight-code-javascript.html


text:
[![Deploy to Bluemix](https://bluemix.net/deploy/button.png)](https://bluemix.net/deploy?repository=https://github.com/ibm-datapalooza/nodejs-starter.git)

## Instructions
1) Click the Deploy to Bluemix button to deploy this application into your Bluemix environment. If you do not have a Bluemix account, you can signup whilst deploying the application. Choose a name for the application which will form the basis of your application URL. Whilst the application is deploying, complete step 2.

2) Register for [Transport API](https://developer.transportapi.com/signup) and create an application. Note down your `APP_ID` and `APP_KEY`. These can be accessed by clicking "Dashboard" and then "Applications" from your TransportAPI account.

3) When the application has finished deploying into Bluemix, it will prompt you to view the app or edit the code. Click "Edit Code" to add your TransportAPI keys.

![Edit code](/docs/editcode.png)

4) Open the .env file and enter in your TransportAPI `APP_ID` and `APP_KEY` into the fields as shown:

![API Keys](/docs/keys.png)

5) Save the file and click the Git logo on the left hand side

![Git Jazz Hub](/docs/git.png)

6) Check that the `.env` file is included in the commit, enter a commit message, click "Commit" and "Push" your changes. This will automatically trigger the Build and Deploy pipeline and update your application in Bluemix.

7) Click "Build & Deploy" to see the status of the deployment. Once this stage has completed, your app will be updated. Navigate to your Bluemix dashboard by clicking the "Dashboard" link in the header. Note that if you have signed up to the London region and you get the following message when clicking "Dashboard" you will need to change the URL to `console.eu-gb.bluemix.net` instead of `console.ng.bluemix.net`.

![region issue](/docs/region.jpg)

8) You should then see your application in your Bluemix dashboard. You can then click the application to get the URL.

9) Your app has now been loaded with your Transport API keys. You can experiment with the application, running queries for nearby train stations, Tfl journey planning, 10 day and 24 hour weather forecasting as well as viewing the OS Map.

10) If you haven't managed to complete the above steps, the application is available at http://dan-datapalooza-demo.mybluemix.net/

## API Documentation

Transport API: http://docs.transportapi.com/index.html?raml=http://transportapi.com/v3/raml/transportapi.raml
TheWeatherChannel: https://www.ng.bluemix.net/docs/services/Weather/index.html
Ordnance Survey: https://apidocs.os.uk/docs/introduction

## Other data
Wimbledon Tennis Data (2014/15) and weather data for Wimbledon (2014/15): https://github.com/ibm-datapalooza/wimbledon-datasets


text:
package com.android.settings.bluetooth;

import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.bluetooth.BluetoothAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.text.Editable;
import android.text.InputFilter;
import android.text.TextWatcher;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import com.android.internal.app.AlertController;
import com.android.settings.R;

/**
 * Dialog fragment for setting the discoverability timeout.
 */
public final class BluetoothVisibilityTimeoutFragment extends DialogFragment
        implements DialogInterface.OnClickListener {

    private final BluetoothDiscoverableEnabler mDiscoverableEnabler;

    public BluetoothVisibilityTimeoutFragment() {
        mDiscoverableEnabler = LocalBluetoothManager.getInstance(getActivity())
                .getDiscoverableEnabler();
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return new AlertDialog.Builder(getActivity())
                .setTitle(R.string.bluetooth_visibility_timeout)
                .setSingleChoiceItems(R.array.bluetooth_visibility_timeout_entries,
                        mDiscoverableEnabler.getDiscoverableTimeoutIndex(), this)
                .setNegativeButton(android.R.string.cancel, null)
                .create();
    }

    public void onClick(DialogInterface dialog, int which) {
        mDiscoverableEnabler.setDiscoverableTimeout(which);
        dismiss();
    }
}


text:
from __future__ import print_function
import sys
sys.path.insert(1,"../../../")
import h2o
from h2o.utils.typechecks import assert_is_type
from random import randrange
import numpy as np
from tests import pyunit_utils
from h2o.frame import H2OFrame

def h2o_H2OFrame_modulo_kfold_column():
    """
    Python API test: h2o.frame.H2OFrame.modulo_kfold_column(n_folds=3)
    """
    python_lists = np.random.randint(-5,5, (1000, 2))
    k = randrange(2,10)
    h2oframe = h2o.H2OFrame(python_obj=python_lists)
    clist = h2oframe.kfold_column(n_folds=k)

    assert_is_type(clist, H2OFrame)     # check return type
    assert clist.asfactor().nlevels()[0]==k, "h2o.H2OFrame.modulo_kfold_column() command is not working."

if __name__ == "__main__":
    pyunit_utils.standalone_test(h2o_H2OFrame_modulo_kfold_column())
else:
    h2o_H2OFrame_modulo_kfold_column()


text:
'use strict';

ffApp.controller('searchController', function searchController($rootScope, $scope, $location, flightService) {

    $scope.Message = "Message from searchController";
    $scope.Advanced = false;
    $scope.FormData = {
        DateRange: '1'
    };

    // Event bindings
    (function () {
        $('.dateRange_chosen').chosen();
        $('.transits_chosen').chosen();
        $('.fClass_chosen').chosen();
        $('.nPassengers_chosen').chosen();

        var $datepicker = $('#departureDate').pikaday({
            firstDay: 1,
            minDate: new Date('2000-01-01'),
            maxDate: new Date('2020-12-31'),
            yearRange: [2000, 2020]
        });
        $('#departureDateBtn').click(function () {
            $datepicker.pikaday('show');
        });

        var ad = $('#arrivalDate').pikaday({
            firstDay: 1,
            minDate: new Date('2000-01-01'),
            maxDate: new Date('2020-12-31'),
            yearRange: [2000, 2020]
        });

        $('#arrivalDateBtn').click(function () {
            ad.pikaday('show');
        });
    })();

    // public functions

    $scope.SubmitForm = function() {
        console.log($scope.FormData);
        uiHelper.ShowBusy();
        flightService.SearchFlight($scope.FormData).then(
            function(data) {
                if (data) {
                    uiHelper.HideBusy();
                    //redirect to graph page
                    $location.path('/view');
                    console.log(data);
                }
            },
            function(status) {
                console.log(status);
            }
        );
    };
});


text:
package com.google.cloud.security.privateca.v1beta1.samples;

// [START privateca_v1beta1_generated_certificateauthorityserviceclient_listreusableconfigs_sync]
import com.google.cloud.security.privateca.v1beta1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1beta1.ListReusableConfigsRequest;
import com.google.cloud.security.privateca.v1beta1.LocationName;
import com.google.cloud.security.privateca.v1beta1.ReusableConfig;

public class SyncListReusableConfigs {

  public static void main(String[] args) throws Exception {
    syncListReusableConfigs();
  }

  public static void syncListReusableConfigs() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {
      ListReusableConfigsRequest request =
          ListReusableConfigsRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .setOrderBy("orderBy-1207110587")
              .build();
      for (ReusableConfig element :
          certificateAuthorityServiceClient.listReusableConfigs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}
// [END privateca_v1beta1_generated_certificateauthorityserviceclient_listreusableconfigs_sync]


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>io.kch.sda</groupId>
    <artifactId>spring.jpa14</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <spring.framework.version>4.3.6.RELEASE</spring.framework.version>
        <javax.servlet.api.version>3.1.0</javax.servlet.api.version>
        <javax.servlet.jsp.api.version>2.3.1</javax.servlet.jsp.api.version>
        <javax.jstl.verison>1.2</javax.jstl.verison>
        <javax.validation.api.version>1.1.0.Final</javax.validation.api.version>
        <hibernate.validator.version>5.4.0.Final</hibernate.validator.version>
        <jackson.version>2.8.6</jackson.version>
        <junit.version>4.12</junit.version>
        <assert.j.version>3.6.2</assert.j.version>
        <json.assert>1.4.0</json.assert>
        <mockito.version>1.10.19</mockito.version>
        <hibernate.version>5.2.7.Final</hibernate.version>
        <mysql.connector.version>6.0.5</mysql.connector.version>
        <commons.dbcp.version>1.4</commons.dbcp.version>
        <hsqldb.version>1.8.0.10</hsqldb.version>
        <dbh2.version>1.4.193</dbh2.version>
        <derby.version>10.13.1.1</derby.version>
        <spring.data.jpa.version>1.11.0.RELEASE</spring.data.jpa.version>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.framework.version}</version>
        </dependency>

        <!-- Servlet dependencies -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${javax.servlet.api.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${javax.servlet.jsp.api.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>${javax.jstl.verison}</version>
        </dependency>

        <!-- Validation dependencies -->
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>${javax.validation.api.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.validator.version}</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.assertj/assertj-core -->
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>${assert.j.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.framework.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.skyscreamer/jsonassert -->
        <dependency>
            <groupId>org.skyscreamer</groupId>
            <artifactId>jsonassert</artifactId>
            <version>${json.assert}</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-all</artifactId>
            <version>${mockito.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring ORM support -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>${commons.dbcp.version}</version>
        </dependency>

        <!-- In memory databases -->
        <!-- HyperSQL DB -->
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
            <version>${hsqldb.version}</version>
        </dependency>

        <!-- H2 DB -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>${dbh2.version}</version>
        </dependency>

        <!-- Derby DB -->
        <dependency>
            <groupId>org.apache.derby</groupId>
            <artifactId>derby</artifactId>
            <version>${derby.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>${spring.data.jpa.version}</version>
        </dependency>

    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.6.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.0.0</version>
                    <configuration>
                        <warSourceDirectory>src/main/webapp</warSourceDirectory>
                        <failOnMissingWebXml>false</failOnMissingWebXml>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>


text:
package org.apache.pulsar.client.impl.schema;

import io.netty.buffer.ByteBuf;
import org.apache.pulsar.client.api.SchemaSerializationException;
import org.apache.pulsar.common.schema.SchemaInfo;
import org.apache.pulsar.common.schema.SchemaType;

/**
 * A schema for `Float`.
 */
public class FloatSchema extends AbstractSchema<Float> {

    private static final FloatSchema INSTANCE;
    private static final SchemaInfo SCHEMA_INFO;

    static {
        SCHEMA_INFO = new SchemaInfoImpl()
                .setName("Float")
                .setType(SchemaType.FLOAT)
                .setSchema(new byte[0]);
        INSTANCE = new FloatSchema();
    }

    public static FloatSchema of() {
        return INSTANCE;
    }

    @Override
    public void validate(byte[] message) {
        if (message.length != 4) {
            throw new SchemaSerializationException("Size of data received by FloatSchema is not 4");
        }
    }

    @Override
    public void validate(ByteBuf message) {
        if (message.readableBytes() != 4) {
            throw new SchemaSerializationException("Size of data received by FloatSchema is not 4");
        }
    }

    @Override
    public byte[] encode(Float message) {
        if (null == message) {
            return null;
        } else {
            long bits = Float.floatToRawIntBits(message);
            return new byte[] {
                (byte) (bits >>> 24),
                (byte) (bits >>> 16),
                (byte) (bits >>> 8),
                (byte) bits
            };
        }
    }

    @Override
    public Float decode(byte[] bytes) {
        if (null == bytes) {
            return null;
        }
        validate(bytes);
        int value = 0;
        for (byte b : bytes) {
            value <<= 8;
            value |= b & 0xFF;
        }
        return Float.intBitsToFloat(value);
    }

    @Override
    public Float decode(ByteBuf byteBuf) {
        if (null == byteBuf) {
            return null;
        }
        validate(byteBuf);
        int value = 0;
        for (int i = 0; i < 4; i++) {
            value <<= 8;
            value |= byteBuf.getByte(i) & 0xFF;
        }

        return Float.intBitsToFloat(value);
    }

    @Override
    public SchemaInfo getSchemaInfo() {
        return SCHEMA_INFO;
    }
}


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Taxon 54(3): 819 (2005)

#### Original name
Peronospora alpina Johanson, 1886

### Remarks
null


text:
define(function() {
  var updateable;
  updateable = {
    modelEvents: {
      "change": "render"
    }
  };
  return updateable;
});


text:
// Copyright (c) 2014 Oleg Eterevsky. Licensed under the MIT license.

/**
 * @file Here goes all the code, specific to Chrome Extension.
 */

function domainFromURL(url, opt_tld, opt_children_tld, opt_not_tld) {
  if (!opt_tld) {
    opt_tld = EFFECTIVE_TLD;
    opt_children_tld = CHILDREN_TLD;
    opt_not_tld = NOT_TLD;
  }

  var fullDomain = url.match(/^(?:\w+:\/\/)?((?:\w[-\w\d]*\.)*\w[-\w\d]*)(?:\/.*)?/)[1];
  if (!fullDomain)
    return null;

  var parts = fullDomain.split('.');
  if (parts.length <= 2)
    return fullDomain;

  var startDomainPart = parts.length - 2;
  for (var i = 0; i < parts.length; i++) {
    var domainSuffix = parts.slice(i).join('.');
    if (opt_not_tld.indexOf(domainSuffix) >= 0) {
      startDomainPart = i;
      break;
    }

    if (opt_children_tld.indexOf(domainSuffix) >= 0) {
      startDomainPart = i - 2;
      break;
    }

    if (opt_tld.indexOf(domainSuffix) >= 0) {
      startDomainPart = i - 1;
      break;
    }
  }

  if (startDomainPart < 0)
    startDomainPart = 0;

  return parts.slice(startDomainPart).join('.');
}

/**
 * @constructor
 */
function Popup(domainSettings) {
  this.domainSettings_ = domainSettings;
  this.tabDomain_ = null;
  document.getElementById('button-options').addEventListener(
      'click', this.showOptions_.bind(this));
  document.getElementById('button-insert').addEventListener(
      'click', this.insert_.bind(this));
  chrome.tabs.query({'active': true, 'currentWindow': true},
                    this.onActiveTabs_.bind(this));
}

Popup.prototype.onActiveTabs_ = function(tabs) {
  if (tabs.length < 1) {
    background.console.error('No active tabs!');
    return;
  }
  var tab = tabs[0];
  var url = tab.url;
  if (!url)
    return;
  this.tabDomain_ = domainFromURL(url);

  domainSettings.get(this.tabDomain_, function(profileId, domain) {
    document.getElementById('domain').value = domain;
    document.getElementById('profile-' + profileId).checked = true;
    onDomainChange();
  });
};

Popup.prototype.insert_ = function() {
  var genPassword = document.getElementById('generated-password').value;
  chrome.tabs.executeScript({
    'allFrames': true,
    'code': 'var pass = "' + genPassword + '";' +
            'var inputs = document.getElementsByTagName("input");' +
            'for (var i = 0; i < inputs.length; i++) {' +
              'var input = inputs[i];' +
              'if (input.getAttribute("type") === "password") {' +
                'input.value = pass;' +
              '}' +
            '}'
  });

  var domain = document.getElementById('domain').value;
  var profileId = getProfile();
  this.domainSettings_.updateProfile(domain, profileId);
  this.domainSettings_.updateSubstitute(this.tabDomain_, domain);
};

Popup.prototype.showOptions_ = function() {
  chrome.tabs.create({'url': 'options.html'});
};

if (typeof exports !== 'undefined') {
  exports.domainFromURL = domainFromURL;
}


text:
BUILD_DIR = Build
CPPUTEST_HOME = /usr/local
PROJECT_HOME = $(shell cd ../../ && pwd)
INCLUDES = -I${CPPUTEST_HOME} -I${PROJECT_HOME}/Arduino -I${PROJECT_HOME}/Hardware \
-ISupport/ -I${PROJECT_HOME}/Common
LIBS = -L${CPPUTEST_HOME}/lib -lCppUTest -lCppUTestExt
DEBUG_FLAGS = -g -ggdb
DEFINES = -DUNIT_TEST

all: make_tests run_tests

make_tests:
	mkdir -p ${BUILD_DIR}
	g++ AllTests.cpp Support/MockArduino.c Support/MockSpiCommon.cpp \
	TestLedFlash.cpp ../LedFlash.cpp TestTC77.cpp ../TC77.cpp \
	TestMX7705.cpp ../MX7705.cpp TestMCP4802.cpp ../MCP4802.cpp \
	${INCLUDES} ${LIBS} ${DEBUG_FLAGS} ${DEFINES} -o ${BUILD_DIR}/tests

run_tests: make_tests
	./${BUILD_DIR}/tests

clean:
	rm -r ${BUILD_DIR}


text:
Contributions
=============

You can contribute by:

- requesting a feature
- reporting a bug
- providing feedback
- submitting code

Check the [Wiki Page](https://github.com/liquidinvestigations/docs/wiki/Contributing) for more information.


text:
import React from 'react';

import categories from '../util/categories';

const styles = color => ({
  legendItem: {
    width: '36px',
    height: '16px',
    backgroundColor: color,
    marginRight: '8px',
  },
  legendItemContainer: {
    display: 'flex',
    marginRight: '24px',
    alignItems: 'center',
    width: '170px',
  },
  container: {
  },
  title: {
    fontWeight: 'bold',
    borderBottom: '1px solid black',
    width: 'fit-content',
  },
});

const LegendItem = ({ color, text }) => {
  return (

       {text}

  );
};

export default function SeedLegend() {
  return (

Thousand Genomes

      {categories.map(cat => <LegendItem color={cat.color} text={cat.text} key={cat.text} />)}

  );
}


text:
package cn.edu.mnnu.ams.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.log4j.NDC;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import cn.edu.mnnu.ams.entity.Role;
import cn.edu.mnnu.ams.entity.User;

@Controller
@RequestMapping({ "Public",""})
public class PublicController extends SuperController {

	public PublicController() {
		System.out.println("PublicController init success.");
	}

	@RequestMapping("updatePwd")
	public String updatePwd(HttpSession session){
		if(amsService.GetSessionRoleType(session)==0) return "forbiden";
		return "Public/updatePwd";
	}
	@RequestMapping(value="updatePwd",method=RequestMethod.POST)
	public @ResponseBody int updatePwdP(HttpSession session,@RequestParam("opwd")String opwd,@RequestParam("npwd")String npwd){
		if(amsService.GetSessionRoleType(session)!=0&&opwd!=null&&npwd!=null){
			return amsService.updatePassword(session.getAttribute("username").toString(),opwd,npwd);
		}
		return 0;
	}
	// 显示登陆页
	@RequestMapping({ "/login", "" })
	public String login(HttpSession session) {
		//session.invalidate();
		return "/Public/login";
	}

	@RequestMapping("/logout")
	public String logout(HttpSession session) {
		return "redirect:/Public/login";
	}

	// 登陆
	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String loginP(HttpSession session, HttpServletRequest request,
			@RequestParam("uid") String username,
			@RequestParam("pwd") String password) {
		String remoteAddr = request.getRemoteAddr();
		NDC.clear();
		NDC.push(remoteAddr);

		if (username != null && password != null) {
			User user = amsService.Login(username, password);
			if(user!=null&&user.getRoleid()>0){
				logger.info("User: [" + username + "] logined.");
				session.setAttribute("user", user);
				Role role = amsService.getRole(user.getRoleid());
				session.setAttribute("role", role);
				if(role.getRoletype()==1)
					return "redirect:/Admin/index";
				if(role.getRoletype()==2)
					return "redirect:/User/index";
				session.invalidate();
			}
		}
		return "/Public/login";
	}

	@RequestMapping("forbiden")
	public void forbiden(){}
}


text:
describe('authFactory Service', function(){
	var authFactory;

// karma start karma.conf.js

	var dummySuccessLogin = {
  						"isadmin": true,
  						"success": true,
  						"message": "successful login admin",
  						// "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6MjMsIm5hbWUiOiJuaWtoaWwgc2hhcm1hIiwidXNlcm5hbWUiOiJuaWtoaWwxMiIsImlzYWRtaW4iOnRydWUsImlhdCI6MTQ3NjgyMzU2MX0.cMRBNPO2nkeaBJhhCsloID0Sux8PLrR_r6F1cKrJjr8"
					};

	beforeEach(angular.mock.module('authService'));

  	beforeEach(angular.mock.inject(function(_Auth_) {
    	authFactory = _Auth_;
  	}));

		it('TEST 1 >> Should Check If Auth Factory is Defined \n', function() {
			expect(authFactory).toBeDefined();
		});

		describe('authFactory Service functions', function(){

		    // A simple test to verify the method all exists
	    	it('TEST 2 >> Should Check if Login Function is Defined', function() {
	      		expect(authFactory.login).toBeDefined();
	      		expect(authFactory.logout).toBeDefined();
	      		expect(authFactory.isLoggedIn).toBeDefined();
	      		expect(authFactory.getUser).toBeDefined();
	  		});
	  	});

		 //  	before(function () {
			//     httpBackend.expectGET('/foos/1').respond(myFooObject);
			//     httpBackend.expectGET('/bars').respond(myBarsArray);
			//     httpBackend.flush();
			// });

		it('TEST 3 >> Should Check if Admin can Login with proper Credentials \n', function() {
			expect(authFactory.login()).toBeDefined();
			expect(authFactory.login('nikhil','1234')).toEqual(dummySuccessLogin);
			// expect(angular.equals(authFactory.login('nikhil','1234'), dummySuccessLogin)).toBe(true);
		});

});


text:
<query id="getCommentStatus" action="select">
    <tables>
        <table name="comments" />
    </tables>
    <columns>
        <column name="substr(regdate,1,8)" alias="date" />
        <column name="count(*)" alias="count" />
    </columns>
    <conditions>
        <condition operation="more" column="regdate" var="date" notnull="notnull" />
    </conditions>
    <navigation>
        <index var="sort_index" default="substr(regdate,1,8)" order="asc" />
        <list_count var="list_count" default="2" />
    </navigation>
    <groups>
        <group column="substr(regdate,1,8)" />
    </groups>
</query>


text:
Class.create("EtherpadLauncher", AbstractEditor, {

    padID:null,
    sessionID: null,
    node: null,

	initialize: function($super, oFormObject, options)
	{
		$super(oFormObject, options);
		if(!ajaxplorer.user || ajaxplorer.user.canWrite()){
			this.canWrite = true;
			this.actions.get("saveButton").observe('click', function(e){
                Event.stop(e);
                this.saveFile();
				return false;
			}.bind(this));
		}else{
			this.canWrite = false;
			this.actions.get("saveButton").hide();
		}
        if(options.context.__className == "Modal"){
            this.actions.get("downloadFileButton").observe('click', function(){
                Event.stop(e);
                if(!this.currentFile) return false;
                pydio.Controller.triggerDownload(ajxpBootstrap.parameters.get('ajxpServerAccess')+'&action=download&file='+this.currentFile);
                return false;
            }.bind(this));
        }else{
            this.actions.get("downloadFileButton").hide();
        }
	},

	open : function($super, nodeOrNodes){
		$super(nodeOrNodes);
        this.node = nodeOrNodes;
        var frame = this.element.down('#ether_box_frame');
		var fileName = nodeOrNodes.getPath();
        var conn = new Connexion();
        var extension = getFileExtension(fileName);
        if(extension == "pad"){
            // Replace 'Save' by 'Export'
            this.actions.get("saveButton").down(".actionbar_button_label").update(MessageHash['etherpad.10']);
        }
        conn.addParameter("get_action", "etherpad_create");
        conn.addParameter("file", fileName);
        conn.onComplete = function(transport){
            var data = transport.responseJSON;
            this.padID = data.padID;
            this.sessionID = data.sessionID;
            console.log(data.url + '?format=text');
            frame.src = data.url;
            fitHeightToBottom(frame, null, 25);
            if(extension != "pad"){
                this.pe = new PeriodicalExecuter(this.observeChanges.bind(this), 5);
            }
        }.bind(this);
        conn.sendAsync();

		if(window.ajxpMobile){
			this.setFullScreen();
			attachMobileScroll(this.textarea, "vertical");
		}

        this.element.observe("editor:enterFSend", function(){
            fitHeightToBottom(frame, null, 25);
        });
        this.element.observe("editor:resize", function(){
            fitHeightToBottom(frame, null, 25);
        });
        this.element.observe("editor:exitFSend", function(){
            fitHeightToBottom(frame, null, 25);
        });

        this.element.observeOnce("editor:close", function(){
            var conn = new Connexion();
            conn.addParameter("get_action", "etherpad_close");
            conn.addParameter("file", this.node.getPath());
            conn.addParameter("pad_id", this.padID);
            conn.addParameter("session_id", this.sessionID);
            conn.sendAsync();
            if(this.pe){
                this.pe.stop();
            }
        }.bind(this));

        this.updateTitle(getBaseName(fileName));
	},

	saveFile : function(){
        if(!this.padID || !this.node) return;
        var conn = new Connexion();
        conn.addParameter("get_action", "etherpad_save");
        conn.addParameter("file", this.node.getPath());
        conn.addParameter("pad_id", this.padID);
        conn.sendAsync();
        this.setModified(false);
	},

    observeChanges: function(){
        if(!this.padID || !this.node) return;
        var conn = new Connexion();
        conn.discrete = true;
        conn.onComplete = function(transport){
            var content = transport.responseText;
            if(this.previousContent && this.previousContent != content){
                this.setModified(true);
            }
            this.previousContent = content;
        }.bind(this);
        conn.addParameter("get_action", "etherpad_get_content");
        conn.addParameter("file", this.node.getPath());
        conn.addParameter("pad_id", this.padID);
        conn.sendAsync();

    }

});


text:
namespace blink {

struct AutoDarkMode;
class ComputedStyle;
class Document;
class GraphicsContext;
class GraphicsContextStateSaver;
class Node;
class TextDecorationOffsetBase;
struct PaintInfo;

// Base class for text painting. Has no dependencies on the layout tree and thus
// provides functionality and definitions that can be shared between both legacy
// layout and LayoutNG.
class CORE_EXPORT TextPainterBase {
  STACK_ALLOCATED();

 public:
  TextPainterBase(GraphicsContext&,
                  const Font&,
                  const PhysicalOffset& text_origin,
                  const PhysicalRect& text_frame_rect,
                  bool horizontal);
  ~TextPainterBase();

  virtual void ClipDecorationsStripe(float upper,
                                     float stripe_width,
                                     float dilation) = 0;

  void SetEmphasisMark(const AtomicString&, TextEmphasisPosition);
  void SetEllipsisOffset(int offset) { ellipsis_offset_ = offset; }

  enum ShadowMode { kBothShadowsAndTextProper, kShadowsOnly, kTextProperOnly };
  static void UpdateGraphicsContext(GraphicsContext&,
                                    const TextPaintStyle&,
                                    GraphicsContextStateSaver&,
                                    ShadowMode = kBothShadowsAndTextProper);
  static sk_sp<SkDrawLooper> CreateDrawLooper(
      const ShadowList* shadow_list,
      DrawLooperBuilder::ShadowAlphaMode,
      const Color& current_color,
      mojom::blink::ColorScheme color_scheme,
      ShadowMode = kBothShadowsAndTextProper);

  void PaintDecorationUnderOrOverLine(GraphicsContext&,
                                      TextDecorationInfo&,
                                      TextDecorationLine line,
                                      const cc::PaintFlags* flags = nullptr);

  static Color TextColorForWhiteBackground(Color);
  static TextPaintStyle TextPaintingStyle(const Document&,
                                          const ComputedStyle&,
                                          const PaintInfo&);
  static TextPaintStyle SelectionPaintingStyle(
      const Document&,
      const ComputedStyle&,
      Node*,
      const PaintInfo&,
      const TextPaintStyle& text_style);

  enum RotationDirection { kCounterclockwise, kClockwise };
  static AffineTransform Rotation(const PhysicalRect& box_rect,
                                  RotationDirection);
  static AffineTransform Rotation(const PhysicalRect& box_rect, WritingMode);

 protected:
  void UpdateGraphicsContext(const TextPaintStyle& style,
                             GraphicsContextStateSaver& saver) {
    UpdateGraphicsContext(graphics_context_, style, saver);
  }
  void DecorationsStripeIntercepts(
      float upper,
      float stripe_width,
      float dilation,
      const Vector<Font::TextIntercept>& text_intercepts);

  // We have two functions to paint text decoations, because we should paint
  // text and decorations in following order:
  //   1. Paint text decorations except line through
  //   2. Paint text
  //   3. Paint line throguh
  void PaintDecorationsExceptLineThrough(const TextDecorationOffsetBase&,
                                         TextDecorationInfo&,
                                         const PaintInfo&,
                                         const Vector<AppliedTextDecoration>&,
                                         const TextPaintStyle& text_style,
                                         bool* has_line_through_decoration,
                                         const cc::PaintFlags* flags = nullptr);
  void PaintDecorationsOnlyLineThrough(TextDecorationInfo&,
                                       const PaintInfo&,
                                       const Vector<AppliedTextDecoration>&,
                                       const TextPaintStyle&,
                                       const cc::PaintFlags* flags = nullptr);

  // Paints emphasis mark as for ideographic full stop character. Callers of
  // this function should rotate canvas to paint emphasis mark at left/right
  // side instead of top/bottom side.
  // |emphasis_mark_font| is used for painting emphasis mark because |font_|
  // may be compressed font (width variants).
  // TODO(yosin): Once legacy inline layout gone, we should move this function
  // to |NGTextCombinePainter|.
  void PaintEmphasisMarkForCombinedText(const TextPaintStyle& text_style,
                                        const Font& emphasis_mark_font,
                                        const AutoDarkMode& auto_dark_mode);

  enum PaintInternalStep { kPaintText, kPaintEmphasisMark };

  GraphicsContext& graphics_context_;
  const Font& font_;
  const PhysicalOffset text_origin_;
  const PhysicalRect text_frame_rect_;
  AtomicString emphasis_mark_;
  int emphasis_mark_offset_ = 0;
  int ellipsis_offset_ = 0;
  const bool horizontal_;
};

inline AffineTransform TextPainterBase::Rotation(
    const PhysicalRect& box_rect,
    RotationDirection rotation_direction) {
  // Why this matrix is correct: consider the case of a clockwise rotation.

  // Let the corner points that define |boxRect| be ABCD, where A is top-left
  // and B is bottom-left.

  // 1. We want B to end up at the same pixel position after rotation as A is
  //    before rotation.
  // 2. Before rotation, B is at (x(), maxY())
  // 3. Rotating clockwise by 90 degrees places B at the coordinates
  //    (-maxY(), x()).
  // 4. Point A before rotation is at (x(), y())
  // 5. Therefore the translation from (3) to (4) is (x(), y()) - (-maxY(), x())
  //    = (x() + maxY(), y() - x())

  // A similar argument derives the counter-clockwise case.
  return rotation_direction == kClockwise
             ? AffineTransform(0, 1, -1, 0, box_rect.X() + box_rect.Bottom(),
                               box_rect.Y() - box_rect.X())
             : AffineTransform(0, -1, 1, 0, box_rect.X() - box_rect.Y(),
                               box_rect.X() + box_rect.Bottom());
}

inline AffineTransform TextPainterBase::Rotation(const PhysicalRect& box_rect,
                                                 WritingMode writing_mode) {
  return Rotation(box_rect, writing_mode != WritingMode::kSidewaysLr
                                ? TextPainterBase::kClockwise
                                : TextPainterBase::kCounterclockwise);
}

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_PAINT_TEXT_PAINTER_BASE_H_