Moved old blackConnect implamentation into java/xpcom/old

git-svn-id: svn://10.0.0.236/trunk@71030 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/java/xpcom/old/test/JSSample.cpp

@@ -0,0 +1,536 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Frank
+ * Mitchell. Portions created by Frank Mitchell are
+ * Copyright (C) 1999 Frank Mitchell. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *    Frank Mitchell (frank.mitchell@sun.com)
+ */
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+#include <iostream.h>
+#include "pratom.h"
+#include "nscore.h"
+#include "nsIFactory.h"
+#include "nsISupports.h"
+#include "nsIComponentManager.h"
+#include "JSISample.h"
+#include "JSSample.h"
+
+class JSSample: public JSISample {  
+public:  
+  // Constructor and Destuctor  
+  JSSample();  
+  virtual ~JSSample();  
+
+  // nsISupports methods  
+  NS_DECL_ISUPPORTS
+
+  // JSISample methods
+  NS_DECL_JSISAMPLE
+
+private:
+  /* attribute long someInt; */
+  PRInt32 someInt_;
+
+  /* attribute boolean someBool; */
+  PRBool someBool_;
+
+  /* readonly attribute long roInt; */
+  PRInt32 roInt_;
+
+  /* attribute double someDouble; */
+  double someDouble_;
+
+  /* attribute string someName; */
+  char *someName_;
+
+  /* readonly attribute string roString; */
+  char *roString_;
+};  
+
+// Globals, need to check if safe to unload module
+//static PRInt32 gLockCnt = 0; 
+// static PRInt32 gInstanceCnt = 0; 
+
+static NS_DEFINE_CID(kSampleCID, JS_SAMPLE_CID);
+
+/* 
+ * JSSampleClass Declaration: see JSSample_private.h
+ */  
+
+/*  
+ * JSComplex Declaration  
+ */  
+class JSComplex : public JSIComplex {
+public: 
+  // Constructor and Destuctor  
+  JSComplex();  
+  JSComplex(int aReal, int aImaginary);
+  virtual ~JSComplex();  
+
+  // nsISupports methods  
+  NS_DECL_ISUPPORTS
+
+  // nsISupports methods  
+  NS_DECL_JSICOMPLEX
+
+private:
+  PRInt32 real_;
+  PRInt32 imaginary_;
+};
+
+/*  
+ * JSSampleFactory Declaration  
+ */  
+
+class JSSampleFactory: public nsIFactory {
+  public:  
+  JSSampleFactory();  
+  virtual ~JSSampleFactory();  
+
+  // nsISupports methods  
+  NS_DECL_ISUPPORTS
+
+  // nsIFactory methods  
+  NS_IMETHOD CreateInstance(nsISupports *aOuter,  
+                            const nsIID &aIID,  
+                            void **aResult);  
+
+  NS_IMETHOD LockFactory(PRBool aLock);  
+};
+
+/*  
+ * JSSample Implementation  
+ */  
+
+JSSample::JSSample()  
+{  
+  // Zero reference counter
+  NS_INIT_ISUPPORTS();
+  // PR_AtomicIncrement(&gInstanceCnt);
+}
+
+JSSample::~JSSample()  
+{  
+  // Make sure there are no dangling pointers to us,
+  // debug only
+  NS_ASSERTION(mRefCnt == 0,"Wrong ref count");
+  // PR_AtomicDecrement(&gInstanceCnt);
+}  
+
+
+// Use the official macros to implement nsISupports
+NS_IMPL_ISUPPORTS1(JSSample, JSISample)
+
+
+NS_IMETHODIMP JSSample::PrintStats()  
+{  
+  cout << "Stats would go here" << endl;
+  return NS_OK;
+}
+
+  /* attribute boolean someInt; */
+NS_IMETHODIMP JSSample::GetSomeInt(PRInt32 *aSomeInt) {
+  *aSomeInt = someInt_;
+  cout << "--> JSSample::GetSomeInt() : " << *aSomeInt << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSSample::SetSomeInt(PRInt32 aSomeInt) {
+  cout << "--> JSSample::SetSomeInt(" << aSomeInt << ")" << endl;
+  someInt_ = aSomeInt;
+  return NS_OK;
+}
+
+  /* attribute boolean someBool; */
+NS_IMETHODIMP JSSample::GetSomeBool(PRInt32 *aSomeBool) {
+  *aSomeBool = someBool_;
+  cout << "--> JSSample::GetSomeBool() : " << *aSomeBool << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSSample::SetSomeBool(PRInt32 aSomeBool) {
+  cout << "--> JSSample::SetSomeBool(" << aSomeBool << ")" << endl;
+  someBool_ = aSomeBool;
+  return NS_OK;
+}
+
+/* readonly attribute long roInt; */
+NS_IMETHODIMP JSSample::GetRoInt(PRInt32 *aRoInt) {
+  *aRoInt = roInt_;
+  cout << "--> JSSample::GetRoInt() : " << *aRoInt << endl;
+  return NS_OK;
+}
+
+
+/* attribute double someDouble; */
+NS_IMETHODIMP JSSample::GetSomeDouble(double *aSomeDouble) {
+  *aSomeDouble = someDouble_;
+  cout << "--> JSSample::GetSomeDouble() : " << *aSomeDouble << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSSample::SetSomeDouble(double aSomeDouble) {
+  cout << "--> JSSample::SetSomeDouble(" << aSomeDouble << ")" << endl;
+  someDouble_ = aSomeDouble;
+  return NS_OK;
+}
+
+
+  /* attribute string someName; */
+NS_IMETHODIMP JSSample::GetSomeName(char * *aSomeName) {
+  *aSomeName = new char[strlen(someName_) + 1];
+  strcpy(*aSomeName, someName_);
+  cout << "--> JSSample::GetSomeName() : '" << *aSomeName << '\'' << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSSample::SetSomeName(const char * aSomeName) {
+  cout << "--> JSSample::SetSomeName('" << aSomeName << "')" << endl;
+  if (aSomeName != someName_) {
+    delete someName_;
+    someName_ = new char[strlen(aSomeName) + 1];
+    strcpy(someName_, aSomeName);
+  }
+  return NS_OK;
+}
+
+
+  /* readonly attribute string roString; */
+NS_IMETHODIMP JSSample::GetRoString(char * *aRoString) {
+  *aRoString = new char[sizeof("Read Only String") + 1];
+  strcpy(*aRoString, "Read Only String");
+  cout << "--> JSSample::GetRoString() : " << *aRoString << '\'' << endl;
+  return NS_OK;
+}
+
+  /* void TakeInt (in long anInt); */
+NS_IMETHODIMP JSSample::TakeInt(PRInt32 anInt) {
+  cout << "--> JSSample::TakeInt(" << anInt << ")" << endl;
+  return NS_OK;
+}
+
+
+  /* long GiveInt (); */
+NS_IMETHODIMP JSSample::GiveInt(PRInt32 *_retval) {
+  *_retval = 42;
+  cout << "--> JSSample::GiveInt() : " << *_retval << endl;
+  return NS_OK;
+}
+
+  /* long GiveAndTake (inout long anInt); */
+NS_IMETHODIMP JSSample::GiveAndTake(PRInt32 *anInt, PRInt32 *_retval) {
+  cout << "--> JSSample::GiveAndTake(" << *anInt << ") => ";
+  *_retval = *anInt;
+  *anInt *= 2;
+  cout << "( " << *anInt << ") : " << *_retval << endl;
+  return NS_OK;
+}
+
+  /* string TooManyArgs (in short oneInt, in short twoInt, inout long redInt, out short blueInt, in double orNothing, in long johnSilver, in boolean algebra); */
+NS_IMETHODIMP JSSample::TooManyArgs(PRInt16 oneInt, 
+                                    PRInt16 twoInt, 
+                                    PRInt32 *redInt, 
+                                    PRInt16 *blueInt, 
+                                    double orNothing, 
+                                    PRInt64 johnSilver, 
+                                    PRBool algebra, 
+                                    char **_retval) {
+  cout << "--> JSSample::TooManyArgs(" 
+       << oneInt << ", " 
+       << twoInt << ", " 
+       << *redInt << ", " 
+       << '-' << ", " 
+       << orNothing << ", " 
+       << johnSilver << ", " 
+       << algebra << ") => ";
+  *redInt = oneInt + twoInt;
+  *blueInt = oneInt - twoInt;
+  this->GetRoString(_retval);
+  cout << "("
+       << oneInt << ", " 
+       << twoInt << ", " 
+       << *redInt << ", " 
+       << *blueInt << ", " 
+       << orNothing << ", " 
+       << johnSilver << ", " 
+       << algebra
+       << ") : " 
+       << *_retval << endl;
+  return NS_OK;
+}
+
+  /* string CatStrings (in string str1, in string str2); */
+NS_IMETHODIMP JSSample::CatStrings(const char *str1, const char *str2, char **_retval) {
+  cout << "--> JSSample::CatStrings(" << str1 << ", "  << str2 << ") : ";
+  *_retval = new char[strlen(str1) + strlen(str2) + 1];
+  strcpy(*_retval, str1);
+  strcat(*_retval, str2);
+  cout << '\'' << *_retval << '\'' << endl;
+  return NS_OK;
+}
+
+  /* void AppendString (inout string str1, in string str2); */
+NS_IMETHODIMP JSSample::AppendString(char **str1, const char *str2) {
+  cout << "--> JSSample::AppendString('" << *str1 << "', '" << str2 << "') => ";
+  char* tmp = new char[strlen(*str1) + strlen(str2) + 1];
+  strcpy(tmp, *str1);
+  strcat(tmp, str2);
+  *str1 = tmp;    // XXX potential memory leak
+  cout << "('" << *str1 << "')" << endl;
+  return NS_OK;
+}
+
+  /* JSIComplex AddComplex (in JSIComplex complex1, in JSIComplex complex2); */
+NS_IMETHODIMP JSSample::AddComplex(JSIComplex *complex1, JSIComplex *complex2, JSIComplex **_retval) {
+  cout << "--> JSSample::AddComplex(" 
+       << complex1 << ", " 
+       << complex2 << ") : ";
+
+  PRInt32 r1, i1, r2, i2;
+  complex1->GetReal(&r1);
+  complex1->GetImaginary(&i1);
+  complex2->GetReal(&r2);
+  complex2->GetImaginary(&i2);
+  *_retval = new JSComplex(r1 + r2, i1 + i2);
+
+  cout << *_retval << endl;
+  return NS_OK;
+}
+
+  /* JSIComplex NewComplex (in long aReal, in long aImaginary); */
+NS_IMETHODIMP JSSample::NewComplex(PRInt32 aReal, PRInt32 aImaginary, JSIComplex **_retval) {
+  cout << "--> JSSample::AddComplex(" 
+       << aReal << ", " 
+       << aImaginary << ") : ";
+
+  *_retval = new JSComplex(aReal, aImaginary);
+
+  cout << *_retval << endl;
+  return NS_OK;
+}
+
+
+  /* void AddInPlace (inout JSIComplex complex1, in JSIComplex complex2); */
+NS_IMETHODIMP JSSample::AddInPlace(JSIComplex **complex1, JSIComplex *complex2) {
+  cout << "--> JSSample::AddInPlace('" 
+       << *complex1 << ", " 
+       << complex2 << ") => ";
+
+  PRInt32 r1, i1, r2, i2;
+  (*complex1)->GetReal(&r1);
+  (*complex1)->GetImaginary(&i1);
+  complex2->GetReal(&r2);
+  complex2->GetImaginary(&i2);
+  r1 += r2;
+  i1 += i2;
+  (*complex1)->SetReal(r1);
+  (*complex1)->SetImaginary(i1);
+  cout << "(" 
+       << *complex1 << ", " 
+       << complex2 << ")"
+       << endl;
+  return NS_OK;
+}
+
+
+  /* long AddTwoInts (in long int1, in long int2); */
+NS_IMETHODIMP JSSample::AddTwoInts(PRInt32 int1, 
+                                   PRInt32 int2, 
+                                   PRInt32 *_retval) {
+  *_retval = int1 + int2;
+  return NS_OK;
+}
+
+/*  
+ * JSComplex Implementation  
+ */  
+
+JSComplex::JSComplex()  
+{  
+  // Zero reference counter
+  NS_INIT_ISUPPORTS();
+  // PR_AtomicIncrement(&gInstanceCnt);
+}
+
+JSComplex::JSComplex(int aReal, int aImaginary) : 
+    real_(aReal), imaginary_(aImaginary)
+{  
+  // Zero reference counter
+  NS_INIT_ISUPPORTS();
+  // PR_AtomicIncrement(&gInstanceCnt);
+}
+
+JSComplex::~JSComplex()  
+{  
+  // Make sure there are no dangling pointers to us,
+  // debug only
+  NS_ASSERTION(mRefCnt == 0,"Wrong ref count");
+  // PR_AtomicDecrement(&gInstanceCnt);
+}  
+
+
+// Use the official macros to implement nsISupports
+NS_IMPL_ISUPPORTS1(JSComplex, JSIComplex)
+
+
+/* attribute long real; */
+NS_IMETHODIMP JSComplex::GetReal(PRInt32 *aReal) {
+  *aReal = real_;
+  cout << "--> JSComplex::GetReal() : " << *aReal << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSComplex::SetReal(PRInt32 aReal) {
+  cout << "--> JSComplex::SetReal(" << aReal << ")" << endl;
+  real_ = aReal;
+  return NS_OK;
+}
+
+/* attribute long imaginary; */
+NS_IMETHODIMP JSComplex::GetImaginary(PRInt32 *aImaginary) {
+  *aImaginary = imaginary_;
+  cout << "--> JSComplex::GetImaginary() : " << *aImaginary << ")" << endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSComplex::SetImaginary(PRInt32 aImaginary) {
+  cout << "--> JSComplex::SetImaginary(" << aImaginary << ")" << endl;
+  imaginary_ = aImaginary;
+  return NS_OK;
+}
+
+
+
+/*  
+ * JSSampleFactory Implementation  
+ */
+
+JSSampleFactory::JSSampleFactory()  
+{  
+  // Zero reference counter
+  NS_INIT_ISUPPORTS();
+  // PR_AtomicIncrement(&gInstanceCnt);
+}
+
+JSSampleFactory::~JSSampleFactory()  
+{  
+  // Make sure there are no dangling pointers to us,
+  // debug only
+  NS_ASSERTION(mRefCnt == 0,"Wrong ref count");
+  // PR_AtomicDecrement(&gInstanceCnt);
+}  
+
+
+// Use the official macros to implement nsISupports
+NS_IMPL_ISUPPORTS1(JSSampleFactory, nsIFactory)
+
+
+NS_IMETHODIMP JSSampleFactory::CreateInstance(nsISupports *aOuter,
+					      const nsIID &aIID, 
+					      void **aResult)
+{
+  if (!aResult) { 
+    return NS_ERROR_NULL_POINTER; 
+  }
+
+  *aResult = nsnull; 
+
+  nsISupports* inst = new JSSample(); 
+
+  if (!inst) { 
+	return NS_ERROR_OUT_OF_MEMORY; 
+  }
+
+  nsresult res = inst->QueryInterface(aIID, aResult); 
+
+  if (NS_FAILED(res)) { 
+	// We didn't get the right interface, so clean up 
+	delete inst; 
+  }
+
+  return res; 
+} 
+
+NS_IMETHODIMP JSSampleFactory::LockFactory(PRBool aLock) 
+{ 
+  if (aLock) { 
+      // PR_AtomicIncrement(&gLockCnt); 
+  } else { 
+      // PR_AtomicDecrement(&gLockCnt); 
+  } 
+
+  return NS_OK;
+} 
+
+
+/////////////////////////////////////////////////////////////////////
+// Exported functions. With these in place we can compile
+// this module into a dynamically loaded and registered
+// component.
+
+extern "C" {
+  NS_EXPORT nsresult NSGetFactory(nsISupports *serviceMgr,
+				  const nsCID &aCID,
+				  const char *aClassName,
+				  const char *aProgID,
+				  nsIFactory **aResult) { 
+    if (!aResult) {
+      return NS_ERROR_NULL_POINTER; 
+    }
+
+    *aResult = nsnull; 
+
+    nsISupports *inst; 
+
+    if (aCID.Equals(kSampleCID)) {
+      // Ok, we know this CID and here is the factory
+      // that can manufacture the objects
+      inst = new JSSampleFactory(); 
+    } else { 
+      return NS_ERROR_NO_INTERFACE; 
+    } 
+
+    if (!inst) {
+      return NS_ERROR_OUT_OF_MEMORY; 
+    }
+
+    nsresult rv = inst->QueryInterface(NS_GET_IID(nsIFactory), 
+				       (void **) aResult); 
+
+    if (NS_FAILED(rv)) { 
+      delete inst; 
+    } 
+
+    return rv; 
+  }
+
+  NS_EXPORT PRBool NSCanUnload(nsISupports* serviceMgr) {
+      return PR_FALSE;
+      // return PRBool(gInstanceCnt == 0 && gLockCnt == 0); 
+  }
+
+  NS_EXPORT nsresult NSRegisterSelf(nsISupports* serviceMgr, 
+				    const char *path) {
+    return nsComponentManager::RegisterComponent(kSampleCID, nsnull, nsnull, 
+					   path, PR_TRUE, PR_TRUE);
+  }
+
+  NS_EXPORT nsresult NSUnregisterSelf(nsISupports* serviceMgr, 
+				      const char *path) {
+    return nsComponentManager::UnregisterComponent(kSampleCID, path);
+  }
+}