Ilka Guigova - Professional Profile

if( !foo != !bar ) {
  ...
}

content: function(text){
    var parse = function(arr){
        var newarr = [];
        for(var i = 0, len = arr.length; i < len; i++){
            if (/[\S]+/.test(arr[i])){
                var subarr = arr[i].replace(/([ ]{2,4}(?=[\S])|\t(?=[\S]))/gm, "").split(/[\n](?=[\S])/m);
                if (subarr.length > 1){
                    newarr.push([subarr[0], parse(subarr.slice(1))]);
                } else {
                    newarr.push(subarr[0]);
                }
            }
        }
        return newarr;
    };
    return parse(text.split(/[\n](?=[\S])/m));
}

      | 2 | 3 | 4 | 5 | 6 | 7  position
------------------------------------------------------
  333 |   | x |   |   | x |   | 2 
 3222 |   | x |   | x |   | x | 1
 2322 | x |   |   | x |   | x | 1
 2232 | x |   | x |   |   | x | 1
 2223 | x |   | x |   | x |   | 1
-------------------------------------------------------
      | 3 | 2 | 2 | 2 | 2 | 3  number of cracks
 
1 | 2 |  3 |  4 |  5 |  6 |  7  wall height
-------------------------------------------------------
5 | 6 |  8 | 10 | 14 | 18 | 24  number of crack-free walls, W
  | 1 |  2 |  2 |  4 |  4 |  8  number of splits, S
  | 0 |  1 |  1 |  2 |  2 |  4  number of splits / 2
  
Graph of row relationships:

  | 2322 |(1) -- |  333 |(2) -- | 2232 | (1)
  
  | 3222 |(1) -- | 2223 |(1) 
  
Graph of significant row relationships: 

  |  333 |  

      | 2 | 3 | 4 | 5 | 6 | 7 | 8  position
------------------------------------------------------
 2332 | x |   |   | x |   |   | x | 0 
22222 | x |   | x |   | x |   | x | 1
 2233 | x |   | x |   |   | x |   | 2
 2323 | x |   |   | x |   | x |   | 1
 3223 |   | x |   | x |   | x |   | 1
 3232 |   | x |   | x |   |   | x | 1
 3322 |   | x |   |   | x |   | x | 2
-------------------------------------------------------
      | 4 | 3 | 2 | 4 | 2 | 3 | 4  number of cracks
 
1 | 2 |  3 |  4 |  5 |  6   wall height
-------------------------------------------------------
7 | 8 | 12 | 18 | 28 | 44	number of crack-free walls, W
  | 2 |  4 |  6 | 10 | 16   number of splits, S
  | 1 |  2 |  3 |  5 |  8	number of splits / 2
  
Graph of row relationships:

  |  2332 |(0) 
  
  |  3223 |(1) -- | 22222 |(1) 
  
  |  3322 |(2) -- |  2233 |(2)      
      |                | 	  
  |  2323 |(1)    |  3232 |(1)
  
Graph of significant row relationships: 

  |  3322 | -- |  2233 |  

      | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9  position
------------------------------------------------------
22223 | x |   | x |   | x |   | x |   | 1 
22232 | x |   | x |   | x |   |   | x | 1
22322 | x |   | x |   |   | x |   | x | 2
23222 | x |   |   | x |   | x |   | x | 1
32222 |   | x |   | x |   | x |   | x | 1
 2333 | x |   |   | x |   |   | x |   | 1
 3233 |   | x |   | x |   |   | x |   | 2
 3323 |   | x |   |   | x |   | x |   | 2
 3332 |   | x |   |   | x |   |   | x | 1
-------------------------------------------------------
      | 5 | 4 | 3 | 4 | 4 | 3 | 4 | 5  number of cracks

1 | 2  |  3 |  4 |  5 |  6  wall height
-------------------------------------------------------
9 | 12 | 18 | 28 |    |     number of crack-free walls, W
  |  3 |  6 | 10 |    |     number of splits, S
  |  1 |  3 |  5 |    |     number of splits / 2
  
Graph of row relationships:

  |  22223 |(1) -- | 32222 |(1) 
  
  |   2333 |(1) -- |  3332 |(1) 
  
  |   3323 |(2) -- | 22322 |(2) -- |  3233 |(2)
       |                                | 
  |  23222 |(1)                    | 22232 |(1)
  
Graph of significant row relationships: 

  |  3323 | -- |  22322 | -- |  3233 | 

  1  import math
  2  
  3  def get_factors(length):
  4  	#NOTE: 10x slower <-> return [(x, y) for x in range(length) for y in range(length) if get_length(x, y) == length]
  5  	factors = [(length/2 - length%2, length%2)]
  6  	while factors[0][0] >= 3:
  7  		factors[0:0] = (factors[0][0] - 3, factors[0][1] + 2),
  8  	return factors	
  9  	
 10  def count_arrangements(x, y): 
 11  	return math.factorial(x + y) / (math.factorial(x) * math.factorial(y))
 12  	
 13  def count_rows(rows): 
 14  	#return reduce(lambda x, y: x + y, [count_arrangements(row[0], row[1]) for row in rows])
 15  	return sum([count_arrangements(row[0], row[1]) for row in rows])
 16  
 17  def count_cracks(length, rows): 
 18  	return sum([count_arrangements(cracks[0], cracks[1])*count_arrangements(row[0]-cracks[0], row[1]-cracks[1]) for row in rows for c in range(2, length - 1) for cracks in get_factors(c) if row[0] - cracks[0] >= 0 if row[1] - cracks[1] >= 0])
 19  	
 20  #-----------------------	
 21  #3329
 22  def get_rows(length, rows = [[0]]):
 23  	if (length > 1):
 24  		if (len(rows[0]) < length): 
 25  			r = [row + [1] for row in rows if ((row[-2:] == [0, 0]) or (row[-2:] == [1, 0]) or (row[-2:] == [0]))]
 26  			
 27  			if (len(rows[0]) < length - 1):		
 28  				r.extend([row + [0] for row in rows if ((row[-1:] == [1]) or (row[-2:] == [1, 0]) or (row[-2:] == [0]))])
 29  			
 30  			return get_rows(length, r)
 31  		else:
 32  			return rows
 33  	return []
 34  			
 35  #33791			
 36  def count_splits(rows): 
 37  	return sum([len(filter(lambda z: z == 1, [count_cracked(row1, row2) for row2 in rows])) - 1 for row1 in rows])
 38  	
 39  def count_cracked(row1, row2): 
 40  	if len(row1) == len(row2): 
 41  		return len(filter(lambda z: z > 1, map(lambda x, y: x + y, row1, row2)))
 42  			
 43  #-----------------------			
 44  def count_walls(length, height):
 45  	pass
 46  	
 47  #-----------------------	
 48  def get_time(fcall, i): 
 49  	import timeit
 50  	t = timeit.Timer("e205_07.%s" % fcall, "import e205_07")
 51  	print "%s, %d calls/batch" % (t.repeat(3, i), i)	
 52  
 53  	
 54  if __name__=='__main__':	
 55  	#get_time("count_walls(32, 2)", 1)
 56  	#get_time("get_rows(32)", 1)

rmdir /s /q "C:\Documents and Settings\<your username>\Local Settings\Application Data\Microsoft\WebsiteCache"
mkdir "C:\Documents and Settings\<your username>\Local Settings\Application Data\Microsoft\WebsiteCache"

-- xml: http://www.setfocus.com/TechnicalArticles/Articles/sql-server-2005-xml.aspx
-- XQuery: http://www.15seconds.com/Issue/050803.htm
DECLARE	@XMLText XML
SET	@XMLText = '
<Customers>
  <Customer>
    <FirstName>Kevin</FirstName>
  </Customer>
  <Customer>
   <FirstName>Steve</FirstName>
  </Customer>
</Customers>'
SELECT	@XMLText.query('/Customers/Customer/FirstName')
/* Output
<FirstName>Kevin</FirstName>
<FirstName>Steve</FirstName>
*/

-- cursor: http://msdn.microsoft.com/en-us/library/ms180169.aspx
DECLARE	@tablename sysname
DECLARE	tables_cursor CURSOR FOR
	SELECT	name
	FROM	sys.objects
	WHERE	type = 'U' AND UPPER(NAME) LIKE UPPER('%%')

OPEN tables_cursor
FETCH NEXT FROM tables_cursor INTO @tablename

WHILE @@FETCH_STATUS = 0
BEGIN
	EXEC ('SELECT Top 1 * FROM ' + @tablename)
	FETCH NEXT FROM tables_cursor INTO @tablename
END
CLOSE tables_cursor
DEALLOCATE tables_cursor

CREATE TABLE #NODE
(
	ID INT IDENTITY, 
	NAME NVARCHAR(MAX)
)

INSERT INTO #NODE VALUES ('TESTNODE')

CREATE TABLE #MAP
(
	ID INT IDENTITY, 
	XML_TEXT NVARCHAR(MAX),
	IS_ENABLED BIT
)

INSERT INTO #MAP VALUES ('<MAP><INPUT><NODE><ID>1</ID></NODE></INPUT><OUTPUT>1234</OUTPUT></MAP>', 1)
INSERT INTO #MAP VALUES ('<MAP><INPUT><NODE><ID>11</ID></NODE></INPUT><OUTPUT>1234</OUTPUT></MAP>', 1)

/*
SET NOCOUNT ON  -- http://msdn.microsoft.com/en-us/library/ms189837.aspx
DECLARE @MAP_ID INT, @MAP_XML XML, @NODE_ID INT
DECLARE	map_cursor CURSOR FOR
	SELECT	ID, XML_TEXT
	FROM	#MAP
 
OPEN map_cursor
FETCH NEXT FROM map_cursor INTO @MAP_ID, @MAP_XML
 
WHILE @@FETCH_STATUS = 0
BEGIN
    SET @NODE_ID = ISNULL(@MAP_XML.value('(//NODE/ID)[1]', 'INT'), 0)

    IF NOT EXISTS(SELECT ID FROM #NODE WHERE ID = @NODE_ID)
    BEGIN
        PRINT 'UNDEFINED NODE ID: ' + CAST(@NODE_ID AS NVARCHAR(30)) + ' IN MAP: ' + CAST(@MAP_XML AS NVARCHAR(MAX))
        UPDATE #MAP SET IS_ENABLED = 0 WHERE ID = @MAP_ID
    END 
     
    FETCH NEXT FROM map_cursor INTO @MAP_ID, @MAP_XML
END
CLOSE map_cursor
DEALLOCATE map_cursor
*/

UPDATE #MAP SET IS_ENABLED = 0
--SELECT *  
FROM #MAP M
LEFT JOIN #NODE N ON N.ID = ISNULL((CAST(M.XML_TEXT AS XML)).value('(//NODE/ID)[1]', 'INT'), 0)
WHERE N.ID IS NULL

DROP TABLE #MAP
DROP TABLE #NODE

-- Consider a list of nodes grouped by DOMAIN_ID as stored in the following temporary table:
CREATE TABLE #NODE 
( 
    ID INT IDENTITY, 
    DOMAIN_ID INT,
    NAME VARCHAR(32)
)

-- Let DOMAIN_ID = 100 represent job nodes, DOMAIN_ID = 500 represent personnel nodes
INSERT INTO #NODE VALUES (100, 'Bloggers')
INSERT INTO #NODE VALUES (100, 'Vloggers')
INSERT INTO #NODE VALUES (500, 'Joe')
INSERT INTO #NODE VALUES (500, 'Jane')
INSERT INTO #NODE VALUES (500, 'Bob')

-- Consider a relationship between nodes of different domains as defined in the following temporary table:
CREATE TABLE #NODE_LINKS 
( 
    ID INT IDENTITY,
    RANK INT,  -- a placeholder for additional logic to rank links and a candidate for an auto-increment input
    LEFT_NODE_ID INT,
    RIGHT_NODE_ID INT
)

-- Let's link personnel to jobs:
-- Each person in personnel is assigned a position/rank within a job. The position / rank is reset for each job.
DECLARE @RANK_OFFSET INT
SELECT @RANK_OFFSET = COUNT(ID) FROM #NODE WHERE DOMAIN_ID = 500

INSERT INTO #NODE_LINKS (RANK, LEFT_NODE_ID, RIGHT_NODE_ID)
SELECT  (ROW_NUMBER() OVER (ORDER BY Jobs.ID) - 1) % @RANK_OFFSET, Jobs.ID, Personnel.ID
FROM	#NODE Jobs 
JOIN 	#NODE Personnel ON Personnel.DOMAIN_ID = 500
WHERE	Jobs.DOMAIN_ID = 100

-- Display the job-personnel links with a counter (a candidate for auto-increment output):
SELECT ROW_NUMBER() OVER (ORDER BY ID) AS COUNTER, * FROM #NODE_LINKS ORDER BY LEFT_NODE_ID

-- Cleanup
DROP TABLE #NODE_LINKS
DROP TABLE #NODE

/* Output:
COUNTER	ID	RANK	LEFT_NODE_ID	RIGHT_NODE_ID
1	1	0	1		3
2	2	1	1		4
3	3	2	1		5
4	4	0	2		3
5	5	1	2		4
6	6	2	2		5
*/

• Add re-parsing logic directly in the code - not smart enough as we do not know what input formats will need to be supported by Module 1 in the future
  
• Apply customizable xsl transformations - providing decoupled solution with a reliable techology
  

<?xml version='1.0' encoding="iso-8859-1"?>
<PRODUCTS>
	<DETAIL>
		<DESC>D1</DESC>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
	</DETAIL>
	<DETAIL>	
		<DESC>D2</DESC>
		<PRODUCT_NAME>ANL</PRODUCT_NAME>
	</DETAIL>
	<DETAIL>
		<DESC>D3</DESC>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
	</DETAIL>
</PRODUCTS> 

<?xml version='1.0' encoding="iso-8859-1"?>
<PRODUCTS>
	<PRODUCT>
		<PRODUCT_NAME>ANL</PRODUCT_NAME>
		<DETAIL>	
			<DESC>D2</DESC>
			<PRODUCT_NAME>ANL</PRODUCT_NAME>
		</DETAIL>
	</PRODUCT>
	<PRODUCT>
		<PRODUCT_NAME>APL</PRODUCT_NAME>
		<DETAIL>
			<DESC>D1</DESC>
			<PRODUCT_NAME>APL</PRODUCT_NAME>
		</DETAIL>
		<DETAIL>
			<DESC>D3</DESC>
			<PRODUCT_NAME>APL</PRODUCT_NAME>
		</DETAIL>
	</PRODUCT>
</PRODUCTS> 

<!-- GROUPING USING THE MUENCHIAN METHOD: http://www.jenitennison.com/xslt/grouping/muenchian.html -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" indent="yes" encoding="iso-8859-1"/>

	<xsl:key name="details-by-product" match="DETAIL" use="PRODUCT_NAME" />

	<xsl:template match="PRODUCTS">
		<PRODUCTS>
		<xsl:for-each select="DETAIL[count(. | key('details-by-product', PRODUCT_NAME)[1]) = 1]">
			<xsl:sort select="PRODUCT_NAME" />
			<PRODUCT>
				<PRODUCT_NAME><xsl:value-of select="PRODUCT_NAME"/></PRODUCT_NAME>
				<xsl:for-each select="key('details-by-product', PRODUCT_NAME)">
					<DETAIL>
					<xsl:apply-templates/>
					</DETAIL>
				</xsl:for-each>
			</PRODUCT>
		</xsl:for-each>
		</PRODUCTS>
	</xsl:template>

	<xsl:template match="@*|node()">
	  <xsl:copy>
		<xsl:apply-templates select="@*|node()"/>
	  </xsl:copy>
	</xsl:template>
</xsl:stylesheet>

//Initiate XSLT in a script: http://msdn.microsoft.com/en-us/library/ms762796(VS.85).aspx
var oArgs = WScript.Arguments;

if (oArgs.length == 0)
{
    WScript.Echo ("Usage : cscript xslt.js xml xsl");
    WScript.Quit();
}
xmlFile = oArgs(0) + ".xml";
xslFile = oArgs(1) + ".xsl";

var xsl = new ActiveXObject("MSXML2.DOMDOCUMENT.6.0");
var xml = new ActiveXObject("MSXML2.DOMDocument.6.0");
xml.validateOnParse = false;
xml.async = false;
xml.load(xmlFile);

if (xml.parseError.errorCode != 0)
    WScript.Echo ("XML Parse Error : " + xml.parseError.reason);

xsl.async = false;
xsl.load(xslFile);

if (xsl.parseError.errorCode != 0)
    WScript.Echo ("XSL Parse Error : " + xsl.parseError.reason);

try
{
    WScript.Echo (xml.transformNode(xsl.documentElement));
}
catch(err)
{
    WScript.Echo ("Transformation Error : " + err.number + "*" + err.description);
}

// XslCompiledTransform: http://msdn.microsoft.com/en-us/library/system.xml.xsl.xslcompiledtransform_members.aspx
// Note: Exception handling is outside of the scope of this tip
// Note: Xml results are loaded into memory and do not have to be written into the file system, if there is no need for it.
private string ApplyStylesheet(string xml, string stylesheet)
{
	if (!string.IsNullOrEmpty(stylesheet))
	{
		//Configure the reader to skip all forms of validation
		XmlReaderSettings settingsReader = new XmlReaderSettings();
		settingsReader.ValidationType = ValidationType.None;
		settingsReader.ProhibitDtd = false;
		settingsReader.XmlResolver = null;

		StringReader strReader = new StringReader(xml);
		XmlReader xmlReader = XmlReader.Create(strReader, settingsReader);
		// use XmlNodeReader xmlReader = new XmlNodeReader(xml); if xml is XmlNode (not a string)

		StringWriter stringWriter = new StringWriter();
		XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);

		XslCompiledTransform xslt = new XslCompiledTransform();
		xslt.Load(stylesheet);
		xslt.Transform(xmlReader, xmlWriter);

		xmlWriter.Close();
		xmlReader.Close();

		return stringWriter.ToString();
	}
	return xml;
}

/*
CREATE TABLE Tasks
(
	ID INT IDENTITY PRIMARY KEY,
	START_TIME DATETIME NOT NULL,
	END_TIME DATETIME NOT NULL
)
GO
INSERT INTO Tasks (START_TIME, END_TIME)
SELECT '2007-01-01 6:34:12 AM', '2007-01-01 12:45:34 PM' UNION ALL
SELECT '2007-01-02 9:23:08 AM', '2007-01-02 5:05:37 PM' UNION ALL
SELECT '2007-01-03 4:34:12 PM', '2007-01-03 4:55:18 PM' UNION ALL
SELECT '2007-01-04 11:02:00 AM', '2007-01-05 2:53:21 PM' UNION ALL
SELECT '2007-01-05 7:52:55 AM', '2007-07-05 9:08:48 AM' UNION ALL
SELECT '2007-01-06 7:59:11 PM', '2010-01-07 1:23:11 AM' UNION ALL
SELECT '2008-12-31 18:20', '2009-01-01 17:20'
GO
*/
-- DURATIONS http://www.sqlteam.com/article/working-with-time-spans-and-durations-in-sql-server
SELECT *,
       (TOTAL_SS) / 31536000 AS YY,
       DATEDIFF(MONTH, 0, END_TIME - START_TIME) % 12 AS MM,
       (TOTAL_SS % 31536000) / 604800 AS WW,  -- 604800 = 7 * 24 * 60 * 60
       (TOTAL_SS % 31536000) / 86400 AS DD,   -- 3153600 = 365 * 24 * 60 * 60
       (TOTAL_SS % 86400) / 3600 AS HH,       -- 86400 = 24 * 60 * 60
       (TOTAL_SS % 3600)/60 AS MI,            -- 3600 = 60 * 60
       (TOTAL_SS % 60) AS SS
FROM   ( -- DATEDIFF (Transact-SQL) / see the comment at the bottom of the page: http://msdn.microsoft.com/en-us/library/ms189794.aspx
         SELECT   START_TIME,
                  END_TIME,
                  END_TIME - START_TIME AS TOTAL,
                  DATEDIFF(ss, 0, END_TIME - START_TIME) AS TOTAL_SS
            FROM  Tasks
            WHERE END_TIME >= START_TIME
        ) AS Q1

-- PADDING http://sqlblogcasts.com/blogs/tonyrogerson/archive/2006/05/29/765.aspx
DECLARE @CH CHAR(1) = '0', 
        @LEN INT = 2, 
        @N INT = 1
SELECT CASE WHEN @LEN > LEN(@N) THEN REPLICATE(@CH, @LEN - LEN(@N)) ELSE '' END + CAST(@N AS VARCHAR) AS PADDED_NUMBER 

-- DATE ONLY http://www.bennadel.com/blog/122-Getting-Only-the-Date-Part-of-a-Date-Time-Stamp-in-SQL-Server.htm 
SELECT CAST (FLOOR(CAST (GETDATE() AS FLOAT)) AS DATETIME) AS DATE_ONLY

public static void BuildQuery(out string sql_cmd, out OleDbParameter[] sql_params, int mode, string tbl, string input, __arglist)
{         
    sql_params = null;
    sql_cmd = String.Empty;
    try
    {
        string[] rcrd_params = input.Split(new Char[] { ',' });

        ArgIterator param_iter = new ArgIterator(__arglist);
        int param_count = param_iter.GetRemainingCount();

        if (param_count != rcrd_params.Length)
        {
            ErrorLogDataSource.LogError(String.Format(
                "Failed to build query with {1}/{2} parameters", 
                param_count, rcrd_params.Length));
            return; 
        }
     
        sql_params = new OleDbParameter[param_count];
        sql_cmd = String.Empty;
        for (int i = 0; i < param_count; i++)
        {
            Object param = TypedReference.ToObject(param_iter.GetNextArg());
            sql_params[i] = new OleDbParameter(rcrd_params[i], param);

            // Logic to append to sql_cmd goes here...

        }
    } catch (Exception ex)
    {
        sql_cmd = String.Empty;
        sql_params = null;

        ErrorLogDataSource.LogException(new Exception(
            String.Format("Failed to build query for {1} with {2} in {3} mode - {0}", 
            ex.Message, tbl, input, mode), 
            ex));
    }
}

public static List<Object> GetStatusTypes(int ID, string Name, string Description, bool Reload, int UserID)
{            
    if ((!isCached) || (Reload))
    {
        DataSourceAdapter.BuildQuery(out sql_cmd, out sql_params, 3, tbl_name, "Name,Description,ID,ID", __arglist("%", "%", -1, -1));
        cache = DataSourceAdapter.ExecQuery(typeof(StatusType), sql_cmd, sql_params);
        isCached = true;
        listFilter = null;
    }
    // ....
}

DESCRIPTION:
        SC is a command line program used for communicating with the
        NT Service Controller and services.
USAGE:
        sc <server> [command] [service name] <option1> <option2>...

        The option <server> has the form "\\ServerName"
        Further help on commands can be obtained by typing: "sc [command]"
        Commands:
          query-----------Queries the status for a service, or
                          enumerates the status for types of services.
          queryex---------Queries the extended status for a service, or
                          enumerates the status for types of services.
          start-----------Starts a service.
          pause-----------Sends a PAUSE control request to a service.
          interrogate-----Sends an INTERROGATE control request to a service.
          continue--------Sends a CONTINUE control request to a service.
          stop------------Sends a STOP request to a service.
          config----------Changes the configuration of a service (persistant).
          description-----Changes the description of a service.
          failure---------Changes the actions taken by a service upon failure.
          qc--------------Queries the configuration information for a service.
          qdescription----Queries the description for a service.
          qfailure--------Queries the actions taken by a service upon failure.
          delete----------Deletes a service (from the registry).
          create----------Creates a service. (adds it to the registry).
          control---------Sends a control to a service.
          sdshow----------Displays a service's security descriptor.
          sdset-----------Sets a service's security descriptor.
          GetDisplayName--Gets the DisplayName for a service.
          GetKeyName------Gets the ServiceKeyName for a service.
          EnumDepend------Enumerates Service Dependencies.

        The following commands do not require a service name:
        sc <server> <command> <option>
          boot------------(ok | bad) Indicates whether the last boot should
                          be saved as the last-known-good boot configuration
          Lock------------Locks the Service Database
          QueryLock-------Queries the LockStatus for the SCManager Database
EXAMPLE:
        sc start MyService

QUERY SESSION [sessionname | username | sessionid]
              [/SERVER:servername] [/MODE] [/FLOW] [/CONNECT] [/COUNTER]

  sessionname         Identifies the session named sessionname.
  username            Identifies the session with user username.
  sessionid           Identifies the session with ID sessionid.
  /SERVER:servername  The server to be queried (default is current).
  /MODE               Display current line settings.
  /FLOW               Display current flow control settings.
  /CONNECT            Display current connect settings.
  /COUNTER            Display current Terminal Services counters information.

RESET SESSION {sessionname | sessionid} [/SERVER:servername] [/V]

  sessionname         Identifies the session with name sessionname.
  sessionid           Identifies the session with ID sessionid.
  /SERVER:servername  The server containing the session (default is current).
  /V                  Display additional information.

<style type='text/css'>
.TableContainer div { 
 width:900px;
 padding-bottom: 20px;
 overflow-x:auto;
 overflow-y:hidden; 
}
.locked {
 position: relative; 
}
</style>

<style type='text/css'>

/* HORIZONTAL SCROLLING */
.TableContainer div{
 width:800px;
 padding-bottom: 20px;
 overflow-x:auto;
 overflow-y:hidden;
}
.locked {
 position: relative; 
}

/* VERTICAL SCROLLING */
.TableContainer tbody{
 height:300px;
 overflow-x:hidden;
 overflow-y:auto;
 padding-right: 20px;
 /*direction:rtl; // Use to place the scroll bar on the left side */
}
/* Prevent IE from using the TBODY height for all the TR's */
.TableContainer tbody tr {
 height: auto;
 white-space: nowrap;
}
</style>

private void MakeAccessible(GridView grid)
        {
            // complements of 
            // http://blog.madskristensen.dk/post/Make-the-GridView-control-accessible.aspx
            if (grid.Rows.Count > 0)
            {
                //This replaces <td> with <th> and adds the scope attribute
                grid.UseAccessibleHeader = true;

                //This will add the <thead> and <tbody> elements
                grid.HeaderRow.TableSection = TableRowSection.TableHeader;

                //This adds the <tfoot> element. Remove if you don't have a footer row
                grid.FooterRow.TableSection = TableRowSection.TableFooter;

                // To avoid out of order Pager rows: The table  must contain row sections in order of header, body, then footer
                // http://msnetprogrammer.net/blog/archive/2007/02/02/5.aspx
                if (grid.TopPagerRow != null)
                {
                    grid.TopPagerRow.TableSection = TableRowSection.TableHeader;
                }
                if (grid.BottomPagerRow != null)
                {
                    grid.BottomPagerRow.TableSection = TableRowSection.TableFooter;
                }

            }
        }

<script type="text/javascript">
/* compliments to http://www.robertnyman.com/index.php?p=256 */
function getElementsByClassName(oElm, strTagName, oClassNames){
	var arrElements = (strTagName == "*" && oElm.all)? oElm.all : oElm.getElementsByTagName(strTagName);
	var arrReturnElements = new Array();
	var arrRegExpClassNames = new Array();
	if(typeof oClassNames == "object"){
		for(var i=0; i<oClassNames.length; i++){
			arrRegExpClassNames.push(new RegExp("(^|\s)" + oClassNames[i].replace(/-/g, "\-") + "(\s|$)"));
		}
	}
	else{
		arrRegExpClassNames.push(new RegExp("(^|\s)" + oClassNames.replace(/-/g, "\-") + "(\s|$)"));
	}
	var oElement;
	var bMatchesAll;
	for(var j=0; j<arrElements.length; j++){
		oElement = arrElements[j];
		bMatchesAll = true;
		for(var k=0; k<arrRegExpClassNames.length; k++){
			if(!arrRegExpClassNames[k].test(oElement.className)){
				bMatchesAll = false;
				break;
			}
		}
		if(bMatchesAll){
			arrReturnElements.push(oElement);
		}
	}
	return (arrReturnElements)
}

function OnScroll(){
    // alert("Scrolling...");    
    var cells = getElementsByClassName(document.getElementByID("div_OLMGridView"), "td", "locked"); 
    for (var i = 0; i < cells.length; i++){
        cells[i].style.left = cells[i].offsetParent.scrollLeft;
    }
}

function GetScroller(){
    var scroller = null; 
    var divs=document.getElementsByTagName('div');
	for (var i = 0; i < divs.length; i++) {
	    if (divs[i].parentNode.getAttribute('class') == "TableContainer"){
	        scroller = divs[i];
	        break;
	    }
	}
	return (scroller);
}

function AddScrollListener(){	
    var scroller = GetScroller();
    // alert(scroller);
    if (scroller != null){
	if (scroller.addEventListener){
            scroller.addEventListener('scroll', OnScroll, false);
        } else if (scroller.attachEvent){
            scroller.attachEvent('scroll', OnScroll);
        }
    }
}// run it on load, or just call the function when you startup.
window.onload = function(){AddScrollListener();}
</script>

<DIV STYLE="background-color: #CFCFCF; position: absolute; 
         left:expression(document.body.clientWidth/2-oDiv.offsetWidth/2);
         top:expression(document.body.clientHeight/2-oDiv.offsetHeight/2)"></DIV>

unit uUPOSFactory;

interface
uses
  uUPOSDeviceControl,
  uUPOSDeviceService;

const
  POSDEVICESINIFILE = 'C:\Program Files\Vivonet\iPOS\Client\PosDevices.ini';

function CreateDeviceService(DeviceName: string): TUPOSDeviceService;
function CreateDeviceControl(DeviceName: string): TUPOSDeviceControl;

implementation

uses
  IniFiles,
  Classes;

function GetClassName(DeviceName: string; DeviceObject: string):string;
var
  iniFile: TIniFile;
begin
  iniFile := TIniFile.Create(POSDEVICESINIFILE);
  Result := iniFile.ReadString(DeviceName, DeviceObject, 'T' + DeviceName + DeviceObject);
  iniFile.Free;
end;

function CreateDeviceService(DeviceName: string): TUPOSDeviceService;
var
  DeviceClass: TPersistentClass;
begin
  try
    DeviceClass := GetClass(GetClassName(DeviceName, 'Service'));
    Result := TUPOSDeviceService(DeviceClass.Create);
  except
    Result := nil;
  end;
end;

function CreateDeviceControl(DeviceName: string): TUPOSDeviceControl;
var
  DeviceClass: TPersistentClass;
begin
  try
    DeviceClass := GetClass(GetClassName(DeviceName, 'Control'));
    Result := TUPOSDeviceControl(DeviceClass.Create);
  except
    Result := nil;
  end;
end;
end.

CURRENCY Currency_Amount;
CString Currency_Text = "";
Currency_Text.Format("%.2f", (float)(Currency_Amount.int64) / 10000);

CURRENCY Currency_Amount; 
COleCurrency COleCurr_Amount;
MSXML::IXMLDOMNodePtr pNode;
pNode = pDOMDoc->selectSingleNode("//Amount/Authorize");
if(pNode)
{
   COleCurr_Amount.ParseCurrency(W2T(pNode->Gettext()));
   Currency_Amount = COleCurr_Amount.m_cur;
}

while PeekMessage(Msg, 0, 0, 0, PM_REMOVE) do begin
  TranslateMessage(Msg);
  DispatchMessage(Msg);
end;

function TApplication.ProcessMessage(var Msg: TMsg): Boolean;
var
  Handled: Boolean;
begin
  Result := False;
  if PeekMessage(Msg, 0, 0, 0, PM_REMOVE) then
  begin
    Result := True;
    if Msg.Message <> WM_QUIT then
    begin
      Handled := False;
      if Assigned(FOnMessage) then FOnMessage(Msg, Handled);
      if not IsHintMsg(Msg) and not Handled and not IsMDIMsg(Msg) and
        not IsKeyMsg(Msg) and not IsDlgMsg(Msg) then
      begin
        TranslateMessage(Msg);
        DispatchMessage(Msg);
      end;
    end
    else
      FTerminate := True;
  end;
end;